Removing quite a bit of absl from iree/. (#6256)
The remaining usage after this is all Status/StatusOr-related.
diff --git a/bindings/python/iree/runtime/CMakeLists.txt b/bindings/python/iree/runtime/CMakeLists.txt
index 8d2f26e..0185f8c 100644
--- a/bindings/python/iree/runtime/CMakeLists.txt
+++ b/bindings/python/iree/runtime/CMakeLists.txt
@@ -27,10 +27,7 @@
iree::modules::hal
iree::vm
iree::vm::bytecode_module
- absl::inlined_vector
- absl::strings
absl::optional
- absl::span
)
iree_py_library(
diff --git a/bindings/python/iree/runtime/hal.cc b/bindings/python/iree/runtime/hal.cc
index e75cfc5..4a5994c 100644
--- a/bindings/python/iree/runtime/hal.cc
+++ b/bindings/python/iree/runtime/hal.cc
@@ -6,7 +6,6 @@
#include "bindings/python/iree/runtime/hal.h"
-#include "absl/container/inlined_vector.h"
#include "iree/hal/api.h"
namespace iree {
diff --git a/bindings/python/iree/runtime/hal.h b/bindings/python/iree/runtime/hal.h
index c42479e..d25c5a6 100644
--- a/bindings/python/iree/runtime/hal.h
+++ b/bindings/python/iree/runtime/hal.h
@@ -7,7 +7,8 @@
#ifndef IREE_BINDINGS_PYTHON_IREE_RT_HAL_H_
#define IREE_BINDINGS_PYTHON_IREE_RT_HAL_H_
-#include "absl/container/inlined_vector.h"
+#include <vector>
+
#include "bindings/python/iree/runtime/binding.h"
#include "bindings/python/iree/runtime/status_utils.h"
#include "iree/hal/api.h"
@@ -74,7 +75,7 @@
return s;
}
- absl::InlinedVector<int32_t, 6> s;
+ std::vector<int32_t> s;
};
class HalBufferView
@@ -140,18 +141,18 @@
}
py::buffer_info ToBufferInfo() {
- absl::InlinedVector<int32_t, 6> shape(iree_hal_buffer_view_shape_rank(bv_));
+ std::vector<int32_t> shape(iree_hal_buffer_view_shape_rank(bv_));
CheckApiStatus(
iree_hal_buffer_view_shape(bv_, shape.size(), shape.data(), nullptr),
"Error getting buffer view shape");
iree_hal_element_type_t element_type =
iree_hal_buffer_view_element_type(bv_);
int32_t element_size = iree_hal_element_byte_count(element_type);
- absl::InlinedVector<py::ssize_t, 6> dims(shape.size());
+ std::vector<py::ssize_t> dims(shape.size());
for (int i = 0; i < shape.size(); ++i) {
dims[i] = shape[i];
}
- absl::InlinedVector<py::ssize_t, 8> strides(shape.size());
+ std::vector<py::ssize_t> strides(shape.size());
if (!strides.empty()) {
strides[shape.size() - 1] = element_size;
for (int i = shape.size() - 2; i >= 0; --i) {
diff --git a/bindings/python/iree/runtime/status_utils.cc b/bindings/python/iree/runtime/status_utils.cc
index 545f62d..30239fb 100644
--- a/bindings/python/iree/runtime/status_utils.cc
+++ b/bindings/python/iree/runtime/status_utils.cc
@@ -6,8 +6,6 @@
#include "bindings/python/iree/runtime/status_utils.h"
-#include "absl/strings/str_cat.h"
-
namespace iree {
namespace python {
@@ -36,12 +34,12 @@
char* iree_message;
size_t iree_message_length;
if (iree_status_to_string(status, &iree_message, &iree_message_length)) {
- full_message = absl::StrCat(
- message, ": ", absl::string_view(iree_message, iree_message_length));
+ full_message = std::string(message) + ": " +
+ std::string(iree_message, iree_message_length);
iree_allocator_free(iree_allocator_system(), iree_message);
} else {
- full_message = absl::StrCat(
- message, ": ", iree_status_code_string(iree_status_code(status)));
+ full_message = std::string(message) + ": " +
+ iree_status_code_string(iree_status_code(status));
}
PyErr_SetString(ApiStatusToPyExcClass(status), full_message.c_str());
diff --git a/bindings/python/iree/runtime/vm.cc b/bindings/python/iree/runtime/vm.cc
index 325ba1f..9eb53f7 100644
--- a/bindings/python/iree/runtime/vm.cc
+++ b/bindings/python/iree/runtime/vm.cc
@@ -6,8 +6,6 @@
#include "bindings/python/iree/runtime/vm.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
#include "absl/types/optional.h"
#include "bindings/python/iree/runtime/status_utils.h"
#include "iree/base/api.h"
@@ -86,7 +84,7 @@
CheckApiStatus(status, "Error creating vm context");
} else {
// Closed set of modules.
- absl::InlinedVector<iree_vm_module_t*, 8> module_handles;
+ std::vector<iree_vm_module_t*> module_handles;
module_handles.resize(modules->size());
for (size_t i = 0, e = module_handles.size(); i < e; ++i) {
module_handles[i] = (*modules)[i]->raw_ptr();
@@ -102,7 +100,7 @@
}
void VmContext::RegisterModules(std::vector<VmModule*> modules) {
- absl::InlinedVector<iree_vm_module_t*, 8> module_handles;
+ std::vector<iree_vm_module_t*> module_handles;
module_handles.resize(modules.size());
for (size_t i = 0, e = module_handles.size(); i < e; ++i) {
module_handles[i] = modules[i]->raw_ptr();
@@ -392,6 +390,20 @@
namespace {
+static std::string ToHexString(const uint8_t* data, size_t length) {
+ static constexpr char kHexChars[] = {'0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+ std::string s(length * 2, ' ');
+ for (size_t i = 0; i < length; ++i) {
+ s[2 * i + 0] = kHexChars[(data[i] & 0xF0) >> 4];
+ s[2 * i + 1] = kHexChars[(data[i] & 0x0F) >> 0];
+ }
+ return s;
+}
+static std::string ToHexString(uint32_t value) {
+ return ToHexString((const uint8_t*)&value, sizeof(value));
+}
+
void AppendListContents(std::string& out, iree_vm_list_t* list,
std::unordered_set<iree_vm_list_t*>& visited) {
for (iree_host_size_t i = 0, e = iree_vm_list_size(list); i < e; ++i) {
@@ -405,24 +417,27 @@
if (i > 0) out.append(", ");
if (iree_vm_variant_is_value(variant)) {
- absl::StrAppend(&out, variant.i32);
+ out += std::to_string(variant.i32);
} else if (iree_vm_variant_is_ref(variant)) {
// Pretty print a subset of ABI impacting known types.
if (iree_hal_buffer_isa(variant.ref)) {
auto* hal_buffer = iree_hal_buffer_deref(variant.ref);
assert(hal_buffer);
- absl::StrAppend(&out, "HalBuffer(",
- iree_hal_buffer_byte_length(hal_buffer), ")");
+ out += std::string("HalBuffer(") +
+ std::to_string(iree_hal_buffer_byte_length(hal_buffer)) + ")";
} else if (iree_hal_buffer_view_isa(variant.ref)) {
auto hal_bv = iree_hal_buffer_view_deref(variant.ref);
- absl::StrAppend(&out, "HalBufferView(");
- absl::InlinedVector<int32_t, 5> shape(
- iree_hal_buffer_view_shape_rank(hal_bv));
+ out += "HalBufferView(";
+ std::vector<int32_t> shape(iree_hal_buffer_view_shape_rank(hal_bv));
iree_hal_buffer_view_shape(hal_bv, shape.size(), shape.data(), nullptr);
- absl::StrAppend(&out, absl::StrJoin(shape, "x"), ":0x",
- absl::Hex(static_cast<uint32_t>(
- iree_hal_buffer_view_element_type(hal_bv))),
- ")");
+ for (size_t i = 0; i < shape.size(); ++i) {
+ if (i > 0) out += 'x';
+ out += std::to_string(shape[i]);
+ }
+ out += ":0x" +
+ ToHexString(static_cast<uint32_t>(
+ iree_hal_buffer_view_element_type(hal_bv))) +
+ ")";
} else if (iree_vm_list_isa(variant.ref)) {
out.append("List[");
iree_vm_list_t* sub_list = iree_vm_list_deref(variant.ref);
@@ -433,7 +448,7 @@
}
out.append("]");
} else {
- absl::StrAppend(&out, "Unknown(", variant.type.ref_type, ")");
+ out += "Unknown(" + std::to_string(variant.type.ref_type) + ")";
}
} else {
out.append("None");
@@ -447,8 +462,8 @@
// The variant list API requires mutability, so we const cast to it internally
// so we can maintain a const DebugString() for callers.
auto mutable_this = const_cast<VmVariantList*>(this);
- std::string s;
- absl::StrAppend(&s, "<VmVariantList(", size(), "): [");
+ std::string s =
+ std::string("<VmVariantList(") + std::to_string(size()) + "): [";
iree_vm_list_t* list = mutable_this->raw_ptr();
std::unordered_set<iree_vm_list_t*> visited;
visited.insert(list);
diff --git a/iree/base/CMakeLists.txt b/iree/base/CMakeLists.txt
index a85c280..f0f14dc 100644
--- a/iree/base/CMakeLists.txt
+++ b/iree/base/CMakeLists.txt
@@ -58,28 +58,28 @@
iree::base::internal::flags
PUBLIC
)
-if(${IREE_ENABLE_THREADING})
- iree_cc_library(
- NAME
- status
- HDRS
- "status.h"
- DEPS
- iree::base::internal::status_internal
- PUBLIC
- )
- iree_cc_test(
- NAME
- status_test
- SRCS
- "status_test.cc"
- DEPS
- ::status
- iree::testing::gtest
- iree::testing::gtest_main
- )
-endif()
+iree_cc_library(
+ NAME
+ status
+ HDRS
+ "status.h"
+ DEPS
+ iree::base::internal::status_internal
+ PUBLIC
+)
+
+iree_cc_test(
+ NAME
+ status_test
+ SRCS
+ "status_test.cc"
+ DEPS
+ ::status
+ iree::testing::gtest
+ iree::testing::gtest_main
+)
+
iree_cc_test(
NAME
string_view_test
diff --git a/iree/base/internal/BUILD b/iree/base/internal/BUILD
index c06028f..d552eac 100644
--- a/iree/base/internal/BUILD
+++ b/iree/base/internal/BUILD
@@ -281,6 +281,28 @@
)
cc_library(
+ name = "span",
+ hdrs = ["span.h"],
+)
+
+cc_library(
+ name = "status_internal",
+ srcs = [
+ "status.cc",
+ "statusor.cc",
+ ],
+ hdrs = [
+ "status.h",
+ "statusor.h",
+ ],
+ deps = [
+ "//iree/base",
+ "//iree/base:core_headers",
+ "//iree/base:logging",
+ ],
+)
+
+cc_library(
name = "synchronization",
srcs = [
"synchronization.c",
@@ -330,8 +352,6 @@
iree_cmake_extra_content(
content = """
-# TODO(#3848): absl has a thread dependency, move this condition after statusor
-# is fixed.
if(NOT ${IREE_ENABLE_THREADING})
return()
endif()
@@ -339,25 +359,6 @@
inline = True,
)
-# TODO(#3848): statusor has the abseil dependency.
-cc_library(
- name = "status_internal",
- srcs = [
- "status.cc",
- "statusor.cc",
- ],
- hdrs = [
- "status.h",
- "statusor.h",
- ],
- deps = [
- "//iree/base",
- "//iree/base:core_headers",
- "//iree/base:logging",
- "@com_google_absl//absl/utility",
- ],
-)
-
cc_library(
name = "threading",
srcs = [
diff --git a/iree/base/internal/CMakeLists.txt b/iree/base/internal/CMakeLists.txt
index cb8dbab..c1ce76b 100644
--- a/iree/base/internal/CMakeLists.txt
+++ b/iree/base/internal/CMakeLists.txt
@@ -296,6 +296,30 @@
iree_cc_library(
NAME
+ span
+ HDRS
+ "span.h"
+ PUBLIC
+)
+
+iree_cc_library(
+ NAME
+ status_internal
+ HDRS
+ "status.h"
+ "statusor.h"
+ SRCS
+ "status.cc"
+ "statusor.cc"
+ DEPS
+ iree::base
+ iree::base::core_headers
+ iree::base::logging
+ PUBLIC
+)
+
+iree_cc_library(
+ NAME
synchronization
HDRS
"call_once.h"
@@ -342,31 +366,12 @@
iree::testing::gtest_main
)
-# TODO(#3848): absl has a thread dependency, move this condition after statusor
-# is fixed.
if(NOT ${IREE_ENABLE_THREADING})
return()
endif()
iree_cc_library(
NAME
- status_internal
- HDRS
- "status.h"
- "statusor.h"
- SRCS
- "status.cc"
- "statusor.cc"
- DEPS
- absl::utility
- iree::base
- iree::base::core_headers
- iree::base::logging
- PUBLIC
-)
-
-iree_cc_library(
- NAME
threading
HDRS
"threading.h"
diff --git a/iree/base/internal/span.h b/iree/base/internal/span.h
new file mode 100644
index 0000000..542d4eb
--- /dev/null
+++ b/iree/base/internal/span.h
@@ -0,0 +1,183 @@
+// Copyright 2021 The IREE Authors
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef IREE_BASE_INTERNAL_SPAN_H_
+#define IREE_BASE_INTERNAL_SPAN_H_
+#ifdef __cplusplus
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+// std::span is available starting in C++20.
+// Prior to that we fall back to our simplified implementation below.
+#if defined(__has_include)
+#if __has_include(<span>) && __cplusplus >= 202002L
+#define IREE_HAVE_STD_SPAN 1
+#include <span>
+#endif // __has_include(<span>)
+#endif // __has_include
+
+namespace iree {
+
+#if defined(IREE_HAVE_STD_SPAN)
+
+// Alias. Once we bump up our minimum C++ version we can drop this entire file.
+template <typename T>
+using span = std::span<T>;
+
+#else
+
+constexpr std::size_t dynamic_extent = std::numeric_limits<std::size_t>::max();
+
+// A pared down version of std::span doing just enough for our uses in IREE.
+// Most of the IREE code started using absl::Span which while close to std::span
+// has some additional functionality of its own and is missing some from std.
+// The benefit here is that means we only need to implement the intersection of
+// the two as none of our code uses those newer std features.
+//
+// https://en.cppreference.com/w/cpp/container/span/subspan
+template <typename T>
+class span {
+ private:
+ template <typename V>
+ using remove_cv_t = typename std::remove_cv<V>::type;
+ template <typename V>
+ using decay_t = typename std::decay<V>::type;
+
+ template <typename C>
+ static constexpr auto GetDataImpl(C& c, char) noexcept -> decltype(c.data()) {
+ return c.data();
+ }
+ static inline char* GetDataImpl(std::string& s, int) noexcept {
+ return &s[0];
+ }
+ template <typename C>
+ static constexpr auto GetData(C& c) noexcept -> decltype(GetDataImpl(c, 0)) {
+ return GetDataImpl(c, 0);
+ }
+
+ template <typename C>
+ using HasSize =
+ std::is_integral<decay_t<decltype(std::declval<C&>().size())> >;
+
+ template <typename V, typename C>
+ using HasData =
+ std::is_convertible<decay_t<decltype(GetData(std::declval<C&>()))>*,
+ V* const*>;
+
+ template <typename C>
+ using EnableIfConvertibleFrom =
+ typename std::enable_if<HasData<T, C>::value && HasSize<C>::value>::type;
+
+ template <typename U>
+ using EnableIfConstView =
+ typename std::enable_if<std::is_const<T>::value, U>::type;
+
+ template <typename U>
+ using EnableIfMutableView =
+ typename std::enable_if<!std::is_const<T>::value, U>::type;
+
+ public:
+ using value_type = remove_cv_t<T>;
+ using pointer = T*;
+ using const_pointer = const T*;
+ using reference = T&;
+ using const_reference = const T&;
+ using iterator = pointer;
+ using const_iterator = const_pointer;
+ using reverse_iterator = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+ using size_type = size_t;
+ using difference_type = ptrdiff_t;
+
+ constexpr span() noexcept : span(nullptr, 0) {}
+ constexpr span(pointer array, size_type length) noexcept
+ : ptr_(array), len_(length) {}
+
+ template <size_type N>
+ constexpr span(T (&a)[N]) noexcept : span(a, N) {}
+
+ template <typename V, typename = EnableIfConvertibleFrom<V>,
+ typename = EnableIfMutableView<V> >
+ explicit span(V& v) noexcept : span(GetData(v), v.size()) {}
+
+ template <typename V, typename = EnableIfConvertibleFrom<V>,
+ typename = EnableIfConstView<V> >
+ constexpr span(const V& v) noexcept : span(GetData(v), v.size()) {}
+
+ template <typename LazyT = T, typename = EnableIfConstView<LazyT> >
+ span(std::initializer_list<value_type> v) noexcept
+ : span(v.begin(), v.size()) {}
+
+ constexpr pointer data() const noexcept { return ptr_; }
+
+ constexpr size_type size() const noexcept { return len_; }
+
+ constexpr size_type length() const noexcept { return size(); }
+
+ constexpr bool empty() const noexcept { return size() == 0; }
+
+ constexpr reference operator[](size_type i) const noexcept {
+ // MSVC 2015 accepts this as constexpr, but not ptr_[i]
+ assert(i < size());
+ return *(data() + i);
+ }
+
+ constexpr reference at(size_type i) const {
+ return i < size() ? *(data() + i) : (std::abort(), *(data() + i));
+ }
+
+ constexpr reference front() const noexcept {
+ assert(size() > 0);
+ return *data();
+ }
+ constexpr reference back() const noexcept {
+ assert(size() > 0);
+ return *(data() + size() - 1);
+ }
+
+ constexpr iterator begin() const noexcept { return data(); }
+ constexpr iterator end() const noexcept { return data() + size(); }
+
+ constexpr reverse_iterator rbegin() const noexcept {
+ return reverse_iterator(end());
+ }
+ constexpr reverse_iterator rend() const noexcept {
+ return reverse_iterator(begin());
+ }
+
+ constexpr span subspan(size_type pos = 0,
+ size_type len = iree::dynamic_extent) const {
+ return (pos <= size()) ? span(data() + pos, std::min(size() - pos, len))
+ : (std::abort(), span());
+ }
+
+ constexpr span first(size_type len) const {
+ return (len <= size()) ? span(data(), len) : (std::abort(), span());
+ }
+
+ constexpr span last(size_type len) const {
+ return (len <= size()) ? span(size() - len + data(), len)
+ : (std::abort(), span());
+ }
+
+ private:
+ pointer ptr_;
+ size_type len_;
+};
+
+#endif // IREE_HAVE_STD_SPAN
+
+} // namespace iree
+
+#endif // __cplusplus
+#endif // IREE_BASE_INTERNAL_SPAN_H_
diff --git a/iree/base/internal/statusor.h b/iree/base/internal/statusor.h
index a91a529..4118b12 100644
--- a/iree/base/internal/statusor.h
+++ b/iree/base/internal/statusor.h
@@ -14,7 +14,6 @@
#include <type_traits>
#include <utility>
-#include "absl/utility/utility.h"
#include "iree/base/api.h"
#include "iree/base/attributes.h"
#include "iree/base/internal/status.h"
@@ -24,11 +23,39 @@
template <typename T>
class IREE_MUST_USE_RESULT StatusOr;
+// https://en.cppreference.com/w/cpp/types/conjunction
+template <typename... Ts>
+struct conjunction : std::true_type {};
+template <typename T, typename... Ts>
+struct conjunction<T, Ts...>
+ : std::conditional<T::value, conjunction<Ts...>, T>::type {};
+template <typename T>
+struct conjunction<T> : T {};
+
+// https://en.cppreference.com/w/cpp/types/disjunction
+template <typename... Ts>
+struct disjunction : std::false_type {};
+template <typename T, typename... Ts>
+struct disjunction<T, Ts...>
+ : std::conditional<T::value, T, disjunction<Ts...>>::type {};
+template <typename T>
+struct disjunction<T> : T {};
+
+// https://en.cppreference.com/w/cpp/types/negation
+template <typename T>
+struct negation : std::integral_constant<bool, !T::value> {};
+
+// https://en.cppreference.com/w/cpp/utility/in_place
+struct in_place_t {
+ explicit in_place_t() = default;
+};
+/*inline*/ constexpr in_place_t in_place{};
+
namespace internal_statusor {
template <typename T, typename U>
using IsStatusOrConversionAmbiguous =
- absl::disjunction<std::is_constructible<T, StatusOr<U>&>,
+ iree::disjunction<std::is_constructible<T, StatusOr<U>&>,
std::is_constructible<T, const StatusOr<U>&>,
std::is_constructible<T, StatusOr<U>&&>,
std::is_constructible<T, const StatusOr<U>&&>,
@@ -39,7 +66,7 @@
template <typename T, typename U>
using IsStatusOrConversionAssigmentAmbiguous =
- absl::disjunction<IsStatusOrConversionAmbiguous<T, U>,
+ iree::disjunction<IsStatusOrConversionAmbiguous<T, U>,
std::is_assignable<T&, StatusOr<U>&>,
std::is_assignable<T&, const StatusOr<U>&>,
std::is_assignable<T&, StatusOr<U>&&>,
@@ -59,18 +86,18 @@
: public IsStatusOrConversionAmbiguous<T, U> {};
template <typename T, typename U>
-using IsStatusOrDirectInitializationAmbiguous = absl::disjunction<
+using IsStatusOrDirectInitializationAmbiguous = iree::disjunction<
std::is_same<StatusOr<T>, std::remove_cv_t<std::remove_reference_t<U>>>,
std::is_same<Status, std::remove_cv_t<std::remove_reference_t<U>>>,
- std::is_same<absl::in_place_t,
+ std::is_same<iree::in_place_t,
std::remove_cv_t<std::remove_reference_t<U>>>,
IsAmbiguousStatusOrForInitialization<T, U>>;
template <typename T, typename U>
-using IsStatusOrDirectInitializationValid = absl::disjunction<
+using IsStatusOrDirectInitializationValid = iree::disjunction<
// The is_same allows nested status ors to ignore this check iff same type.
std::is_same<T, std::remove_cv_t<std::remove_reference_t<U>>>,
- absl::negation<IsStatusOrDirectInitializationAmbiguous<T, U>>>;
+ iree::negation<IsStatusOrDirectInitializationAmbiguous<T, U>>>;
class Helper {
public:
@@ -140,7 +167,7 @@
}
template <typename... Args>
- explicit StatusOrData(absl::in_place_t, Args&&... args)
+ explicit StatusOrData(iree::in_place_t, Args&&... args)
: data_(std::forward<Args>(args)...) {
MakeStatus();
}
@@ -322,11 +349,11 @@
template <
typename U,
std::enable_if_t<
- absl::conjunction<
- absl::negation<std::is_same<T, U>>,
+ iree::conjunction<
+ iree::negation<std::is_same<T, U>>,
std::is_constructible<T, const U&>,
std::is_convertible<const U&, T>,
- absl::negation<internal_statusor::IsStatusOrConversionAmbiguous<
+ iree::negation<internal_statusor::IsStatusOrConversionAmbiguous<
T, U>>>::value,
int> = 0>
StatusOr(const StatusOr<U>& other) // NOLINT
@@ -334,11 +361,11 @@
template <
typename U,
std::enable_if_t<
- absl::conjunction<
- absl::negation<std::is_same<T, U>>,
+ iree::conjunction<
+ iree::negation<std::is_same<T, U>>,
std::is_constructible<T, const U&>,
- absl::negation<std::is_convertible<const U&, T>>,
- absl::negation<internal_statusor::IsStatusOrConversionAmbiguous<
+ iree::negation<std::is_convertible<const U&, T>>,
+ iree::negation<internal_statusor::IsStatusOrConversionAmbiguous<
T, U>>>::value,
int> = 0>
explicit StatusOr(const StatusOr<U>& other)
@@ -347,10 +374,10 @@
template <
typename U,
std::enable_if_t<
- absl::conjunction<
- absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
+ iree::conjunction<
+ iree::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
std::is_convertible<U&&, T>,
- absl::negation<internal_statusor::IsStatusOrConversionAmbiguous<
+ iree::negation<internal_statusor::IsStatusOrConversionAmbiguous<
T, U>>>::value,
int> = 0>
StatusOr(StatusOr<U>&& other) // NOLINT
@@ -358,10 +385,10 @@
template <
typename U,
std::enable_if_t<
- absl::conjunction<
- absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
- absl::negation<std::is_convertible<U&&, T>>,
- absl::negation<internal_statusor::IsStatusOrConversionAmbiguous<
+ iree::conjunction<
+ iree::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
+ iree::negation<std::is_convertible<U&&, T>>,
+ iree::negation<internal_statusor::IsStatusOrConversionAmbiguous<
T, U>>>::value,
int> = 0>
explicit StatusOr(StatusOr<U>&& other)
@@ -373,11 +400,11 @@
template <
typename U,
std::enable_if_t<
- absl::conjunction<
- absl::negation<std::is_same<T, U>>,
+ iree::conjunction<
+ iree::negation<std::is_same<T, U>>,
std::is_constructible<T, const U&>,
std::is_assignable<T, const U&>,
- absl::negation<
+ iree::negation<
internal_statusor::IsStatusOrConversionAssigmentAmbiguous<
T, U>>>::value,
int> = 0>
@@ -388,10 +415,10 @@
template <
typename U,
std::enable_if_t<
- absl::conjunction<
- absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
+ iree::conjunction<
+ iree::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
std::is_assignable<T, U&&>,
- absl::negation<
+ iree::negation<
internal_statusor::IsStatusOrConversionAssigmentAmbiguous<
T, U>>>::value,
int> = 0>
@@ -428,9 +455,9 @@
// Constructs the inner value T in-place using the provided args, using the
// T(args...) constructor.
template <typename... Args>
- explicit StatusOr(absl::in_place_t, Args&&... args);
+ explicit StatusOr(iree::in_place_t, Args&&... args);
template <typename U, typename... Args>
- explicit StatusOr(absl::in_place_t, std::initializer_list<U> ilist,
+ explicit StatusOr(iree::in_place_t, std::initializer_list<U> ilist,
Args&&... args);
// Constructs the inner value T in-place using the provided args, using the
@@ -441,24 +468,24 @@
template <
typename U = T,
std::enable_if_t<
- absl::conjunction<
+ iree::conjunction<
internal_statusor::IsStatusOrDirectInitializationValid<T, U&&>,
std::is_constructible<T, U&&>,
std::is_convertible<U&&, T>>::value,
int> = 0>
StatusOr(U&& u) // NOLINT
- : StatusOr(absl::in_place, std::forward<U>(u)) {}
+ : StatusOr(iree::in_place, std::forward<U>(u)) {}
template <
typename U = T,
std::enable_if_t<
- absl::conjunction<
+ iree::conjunction<
internal_statusor::IsStatusOrDirectInitializationValid<T, U&&>,
std::is_constructible<T, U&&>,
- absl::negation<std::is_convertible<U&&, T>>>::value,
+ iree::negation<std::is_convertible<U&&, T>>>::value,
int> = 0>
explicit StatusOr(U&& u) // NOLINT
- : StatusOr(absl::in_place, std::forward<U>(u)) {}
+ : StatusOr(iree::in_place, std::forward<U>(u)) {}
// Returns this->ok()
explicit operator bool() const { return ok(); }
@@ -565,14 +592,14 @@
}
template <typename T>
template <typename... Args>
-StatusOr<T>::StatusOr(absl::in_place_t, Args&&... args)
- : Base(absl::in_place, std::forward<Args>(args)...) {}
+StatusOr<T>::StatusOr(iree::in_place_t, Args&&... args)
+ : Base(iree::in_place, std::forward<Args>(args)...) {}
template <typename T>
template <typename U, typename... Args>
-StatusOr<T>::StatusOr(absl::in_place_t, std::initializer_list<U> ilist,
+StatusOr<T>::StatusOr(iree::in_place_t, std::initializer_list<U> ilist,
Args&&... args)
- : Base(absl::in_place, ilist, std::forward<Args>(args)...) {}
+ : Base(iree::in_place, ilist, std::forward<Args>(args)...) {}
template <typename T>
const Status& StatusOr<T>::status() const& {
diff --git a/iree/base/string_view.c b/iree/base/string_view.c
index 4f4b2ad..efbae6e 100644
--- a/iree/base/string_view.c
+++ b/iree/base/string_view.c
@@ -212,6 +212,15 @@
return offset;
}
+IREE_API_EXPORT void iree_string_view_replace_char(iree_string_view_t value,
+ char old_char,
+ char new_char) {
+ char* p = (char*)value.data;
+ for (iree_host_size_t i = 0; i < value.size; ++i) {
+ if (p[i] == old_char) p[i] = new_char;
+ }
+}
+
static bool iree_string_view_match_pattern_impl(iree_string_view_t value,
iree_string_view_t pattern) {
iree_host_size_t next_char_index = iree_string_view_find_first_of(
diff --git a/iree/hal/BUILD b/iree/hal/BUILD
index 362e8e9..6f7fc51 100644
--- a/iree/hal/BUILD
+++ b/iree/hal/BUILD
@@ -78,9 +78,8 @@
":hal",
"//iree/base",
"//iree/base:status",
+ "//iree/base/internal:span",
"//iree/testing:gtest",
"//iree/testing:gtest_main",
- "@com_google_absl//absl/strings",
- "@com_google_absl//absl/types:span",
],
)
diff --git a/iree/hal/CMakeLists.txt b/iree/hal/CMakeLists.txt
index ba136e2..a7cdd5f 100644
--- a/iree/hal/CMakeLists.txt
+++ b/iree/hal/CMakeLists.txt
@@ -68,9 +68,8 @@
"string_util_test.cc"
DEPS
::hal
- absl::span
- absl::strings
iree::base
+ iree::base::internal::span
iree::base::status
iree::testing::gtest
iree::testing::gtest_main
diff --git a/iree/hal/buffer.h b/iree/hal/buffer.h
index ccdc834..3ea2fe0 100644
--- a/iree/hal/buffer.h
+++ b/iree/hal/buffer.h
@@ -249,8 +249,8 @@
// be unmapped before any command may use it.
//
// Buffers may map (roughly) 1:1 with an allocation either from the host heap or
-// a device. iree_hal_buffer_Subspan can be used to reference subspans of
-// buffers like absl::Span - though unlike absl::Span the returned Buffer holds
+// a device. iree_hal_buffer_subspan can be used to reference subspans of
+// buffers like std::span - though unlike std::span the returned buffer holds
// a reference to the parent buffer.
typedef struct iree_hal_buffer_t iree_hal_buffer_t;
diff --git a/iree/hal/string_util_test.cc b/iree/hal/string_util_test.cc
index 2f00ae8..5ba69bf 100644
--- a/iree/hal/string_util_test.cc
+++ b/iree/hal/string_util_test.cc
@@ -11,9 +11,8 @@
#include <utility>
#include <vector>
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
#include "iree/base/api.h"
+#include "iree/base/internal/span.h"
#include "iree/base/status.h"
#include "iree/hal/api.h"
#include "iree/testing/gtest.h"
@@ -33,7 +32,7 @@
// Parses a serialized set of shape dimensions using the canonical shape format
// (the same as produced by FormatShape).
-StatusOr<Shape> ParseShape(absl::string_view value) {
+StatusOr<Shape> ParseShape(const std::string& value) {
Shape shape(6);
iree_host_size_t actual_rank = 0;
iree_status_t status;
@@ -48,7 +47,7 @@
}
// Converts shape dimensions into a `4x5x6` format.
-StatusOr<std::string> FormatShape(absl::Span<const iree_hal_dim_t> value) {
+StatusOr<std::string> FormatShape(iree::span<const iree_hal_dim_t> value) {
std::string buffer(16, '\0');
iree_host_size_t actual_length = 0;
iree_status_t status;
@@ -64,7 +63,7 @@
// Parses a serialized iree_hal_element_type_t. The format is the same as
// produced by FormatElementType.
-StatusOr<iree_hal_element_type_t> ParseElementType(absl::string_view value) {
+StatusOr<iree_hal_element_type_t> ParseElementType(const std::string& value) {
iree_hal_element_type_t element_type = IREE_HAL_ELEMENT_TYPE_NONE;
iree_status_t status = iree_hal_parse_element_type(
iree_string_view_t{value.data(), value.size()}, &element_type);
@@ -93,9 +92,9 @@
// For example, "1.2" of type IREE_HAL_ELEMENT_TYPE_FLOAT32 will write the 4
// byte float value of 1.2 to |buffer|.
template <typename T>
-Status ParseElement(absl::string_view value,
+Status ParseElement(const std::string& value,
iree_hal_element_type_t element_type,
- absl::Span<T> buffer) {
+ iree::span<T> buffer) {
return iree_hal_parse_element(
iree_string_view_t{value.data(), value.size()}, element_type,
iree_byte_span_t{reinterpret_cast<uint8_t*>(buffer.data()),
@@ -126,9 +125,9 @@
// produced by FormatBufferElements. Supports additional inputs of
// empty to denote a 0 fill and a single element to denote a splat.
template <typename T>
-Status ParseBufferElements(absl::string_view value,
+Status ParseBufferElements(const std::string& value,
iree_hal_element_type_t element_type,
- absl::Span<T> buffer) {
+ iree::span<T> buffer) {
IREE_RETURN_IF_ERROR(
iree_hal_parse_buffer_elements(
iree_string_view_t{value.data(), value.size()}, element_type,
@@ -146,7 +145,7 @@
// |max_element_count| can be used to limit the total number of elements printed
// when the count may be large. Elided elements will be replaced with `...`.
template <typename T>
-StatusOr<std::string> FormatBufferElements(absl::Span<const T> data,
+StatusOr<std::string> FormatBufferElements(iree::span<const T> data,
const Shape& shape,
iree_hal_element_type_t element_type,
size_t max_element_count) {
@@ -222,10 +221,10 @@
// For example, "1.2" of type float (IREE_HAL_ELEMENT_TYPE_FLOAT32) will return
// 1.2f.
template <typename T>
-inline StatusOr<T> ParseElement(absl::string_view value) {
+inline StatusOr<T> ParseElement(const std::string& value) {
T result = T();
IREE_RETURN_IF_ERROR(ParseElement(value, ElementTypeFromCType<T>::value,
- absl::MakeSpan(&result, 1)));
+ iree::span<T>(&result, 1)));
return result;
}
@@ -241,8 +240,8 @@
// produced by FormatBufferElements. Supports additional inputs of
// empty to denote a 0 fill and a single element to denote a splat.
template <typename T>
-inline Status ParseBufferElements(absl::string_view value,
- absl::Span<T> buffer) {
+inline Status ParseBufferElements(const std::string& value,
+ iree::span<T> buffer) {
return ParseBufferElements(value, ElementTypeFromCType<T>::value, buffer);
}
@@ -251,14 +250,14 @@
// additional inputs of empty to denote a 0 fill and a single element to denote
// a splat.
template <typename T>
-inline StatusOr<std::vector<T>> ParseBufferElements(absl::string_view value,
+inline StatusOr<std::vector<T>> ParseBufferElements(const std::string& value,
const Shape& shape) {
iree_host_size_t element_count = 1;
for (size_t i = 0; i < shape.size(); ++i) {
element_count *= shape[i];
}
std::vector<T> result(element_count);
- IREE_RETURN_IF_ERROR(ParseBufferElements(value, absl::MakeSpan(result)));
+ IREE_RETURN_IF_ERROR(ParseBufferElements(value, iree::span<T>(result)));
return std::move(result);
}
@@ -270,7 +269,7 @@
// when the count may be large. Elided elements will be replaced with `...`.
template <typename T>
StatusOr<std::string> FormatBufferElements(
- absl::Span<const T> data, const Shape& shape,
+ iree::span<const T> data, const Shape& shape,
size_t max_element_count = SIZE_MAX) {
return FormatBufferElements(data, shape, ElementTypeFromCType<T>::value,
max_element_count);
@@ -426,7 +425,7 @@
// Creates a buffer view with a reference to the given |buffer|.
static StatusOr<BufferView> Create(Buffer buffer,
- absl::Span<const iree_hal_dim_t> shape,
+ iree::span<const iree_hal_dim_t> shape,
iree_hal_element_type_t element_type) {
BufferView buffer_view;
iree_status_t status = iree_hal_buffer_view_create(
@@ -476,7 +475,7 @@
// Parses a serialized set of buffer elements in the canonical tensor format
// (the same as produced by Format).
- static StatusOr<BufferView> Parse(absl::string_view value,
+ static StatusOr<BufferView> Parse(const std::string& value,
Allocator allocator) {
BufferView buffer_view;
iree_status_t status = iree_hal_buffer_view_parse(
@@ -678,44 +677,44 @@
TEST(ElementStringUtilTest, ParseOpaqueElement) {
std::vector<uint8_t> buffer1(1);
IREE_EXPECT_OK(ParseElement("FF", IREE_HAL_ELEMENT_TYPE_OPAQUE_8,
- absl::MakeSpan(buffer1)));
+ iree::span<uint8_t>(buffer1)));
EXPECT_THAT(buffer1, Eq(std::vector<uint8_t>{0xFF}));
std::vector<uint16_t> buffer2(1);
IREE_EXPECT_OK(ParseElement("FFCD", IREE_HAL_ELEMENT_TYPE_OPAQUE_16,
- absl::MakeSpan(buffer2)));
+ iree::span<uint16_t>(buffer2)));
EXPECT_THAT(buffer2, Eq(std::vector<uint16_t>{0xCDFFu}));
std::vector<uint32_t> buffer4(1);
IREE_EXPECT_OK(ParseElement("FFCDAABB", IREE_HAL_ELEMENT_TYPE_OPAQUE_32,
- absl::MakeSpan(buffer4)));
+ iree::span<uint32_t>(buffer4)));
EXPECT_THAT(buffer4, Eq(std::vector<uint32_t>{0xBBAACDFFu}));
std::vector<uint64_t> buffer8(1);
IREE_EXPECT_OK(ParseElement("FFCDAABBCCDDEEFF",
IREE_HAL_ELEMENT_TYPE_OPAQUE_64,
- absl::MakeSpan(buffer8)));
+ iree::span<uint64_t>(buffer8)));
EXPECT_THAT(buffer8, Eq(std::vector<uint64_t>{0xFFEEDDCCBBAACDFFull}));
}
TEST(ElementStringUtilTest, ParseOpaqueElementInvalid) {
std::vector<uint8_t> buffer0(0);
- EXPECT_THAT(
- ParseElement("", IREE_HAL_ELEMENT_TYPE_OPAQUE_8, absl::MakeSpan(buffer0)),
- StatusIs(StatusCode::kInvalidArgument));
+ EXPECT_THAT(ParseElement("", IREE_HAL_ELEMENT_TYPE_OPAQUE_8,
+ iree::span<uint8_t>(buffer0)),
+ StatusIs(StatusCode::kInvalidArgument));
EXPECT_THAT(ParseElement("FF", IREE_HAL_ELEMENT_TYPE_OPAQUE_8,
- absl::MakeSpan(buffer0)),
+ iree::span<uint8_t>(buffer0)),
StatusIs(StatusCode::kInvalidArgument));
std::vector<uint8_t> buffer1(1);
- EXPECT_THAT(
- ParseElement("", IREE_HAL_ELEMENT_TYPE_OPAQUE_8, absl::MakeSpan(buffer1)),
- StatusIs(StatusCode::kInvalidArgument));
+ EXPECT_THAT(ParseElement("", IREE_HAL_ELEMENT_TYPE_OPAQUE_8,
+ iree::span<uint8_t>(buffer1)),
+ StatusIs(StatusCode::kInvalidArgument));
EXPECT_THAT(ParseElement("F", IREE_HAL_ELEMENT_TYPE_OPAQUE_8,
- absl::MakeSpan(buffer1)),
+ iree::span<uint8_t>(buffer1)),
StatusIs(StatusCode::kInvalidArgument));
EXPECT_THAT(ParseElement("FFC", IREE_HAL_ELEMENT_TYPE_OPAQUE_8,
- absl::MakeSpan(buffer1)),
+ iree::span<uint8_t>(buffer1)),
StatusIs(StatusCode::kInvalidArgument));
}
@@ -759,28 +758,28 @@
TEST(BufferElementsStringUtilTest, ParseBufferElements) {
// Empty:
std::vector<int8_t> buffer0(0);
- IREE_EXPECT_OK(ParseBufferElements<int8_t>("", absl::MakeSpan(buffer0)));
+ IREE_EXPECT_OK(ParseBufferElements<int8_t>("", iree::span<int8_t>(buffer0)));
EXPECT_THAT(buffer0, Eq(std::vector<int8_t>{}));
std::vector<int8_t> buffer8(8, 123);
- IREE_EXPECT_OK(ParseBufferElements<int8_t>("", absl::MakeSpan(buffer8)));
+ IREE_EXPECT_OK(ParseBufferElements<int8_t>("", iree::span<int8_t>(buffer8)));
EXPECT_THAT(buffer8, Eq(std::vector<int8_t>{0, 0, 0, 0, 0, 0, 0, 0}));
// Scalar:
std::vector<int8_t> buffer1(1);
- IREE_EXPECT_OK(ParseBufferElements<int8_t>("1", absl::MakeSpan(buffer1)));
+ IREE_EXPECT_OK(ParseBufferElements<int8_t>("1", iree::span<int8_t>(buffer1)));
EXPECT_THAT(buffer1, Eq(std::vector<int8_t>{1}));
// Splat:
- IREE_EXPECT_OK(ParseBufferElements<int8_t>("3", absl::MakeSpan(buffer8)));
+ IREE_EXPECT_OK(ParseBufferElements<int8_t>("3", iree::span<int8_t>(buffer8)));
EXPECT_THAT(buffer8, Eq(std::vector<int8_t>{3, 3, 3, 3, 3, 3, 3, 3}));
// 1:1:
- IREE_EXPECT_OK(ParseBufferElements<int8_t>("2", absl::MakeSpan(buffer1)));
+ IREE_EXPECT_OK(ParseBufferElements<int8_t>("2", iree::span<int8_t>(buffer1)));
EXPECT_THAT(buffer1, Eq(std::vector<int8_t>{2}));
std::vector<int16_t> buffer8i16(8);
IREE_EXPECT_OK(ParseBufferElements<int16_t>("0 1 2 3 4 5 6 7",
- absl::MakeSpan(buffer8i16)));
+ iree::span<int16_t>(buffer8i16)));
EXPECT_THAT(buffer8i16, Eq(std::vector<int16_t>{0, 1, 2, 3, 4, 5, 6, 7}));
std::vector<int32_t> buffer8i32(8);
IREE_EXPECT_OK(ParseBufferElements<int32_t>("[0 1 2 3] [4 5 6 7]",
- absl::MakeSpan(buffer8i32)));
+ iree::span<int32_t>(buffer8i32)));
EXPECT_THAT(buffer8i32, Eq(std::vector<int32_t>{0, 1, 2, 3, 4, 5, 6, 7}));
}
@@ -788,22 +787,22 @@
std::vector<uint16_t> buffer3i16(3);
IREE_EXPECT_OK(ParseBufferElements("0011 2233 4455",
IREE_HAL_ELEMENT_TYPE_OPAQUE_16,
- absl::MakeSpan(buffer3i16)));
+ iree::span<uint16_t>(buffer3i16)));
EXPECT_THAT(buffer3i16, Eq(std::vector<uint16_t>{0x1100, 0x3322, 0x5544}));
}
TEST(BufferElementsStringUtilTest, ParseBufferElementsInvalid) {
std::vector<int8_t> buffer0(0);
- EXPECT_THAT(ParseBufferElements("abc", absl::MakeSpan(buffer0)),
+ EXPECT_THAT(ParseBufferElements("abc", iree::span<int8_t>(buffer0)),
StatusIs(StatusCode::kOutOfRange));
std::vector<int8_t> buffer1(1);
- EXPECT_THAT(ParseBufferElements("abc", absl::MakeSpan(buffer1)),
+ EXPECT_THAT(ParseBufferElements("abc", iree::span<int8_t>(buffer1)),
StatusIs(StatusCode::kInvalidArgument));
std::vector<int8_t> buffer8(8);
- EXPECT_THAT(ParseBufferElements("1 2 3", absl::MakeSpan(buffer8)),
+ EXPECT_THAT(ParseBufferElements("1 2 3", iree::span<int8_t>(buffer8)),
StatusIs(StatusCode::kOutOfRange));
std::vector<int8_t> buffer4(4);
- EXPECT_THAT(ParseBufferElements("1 2 3 4 5", absl::MakeSpan(buffer4)),
+ EXPECT_THAT(ParseBufferElements("1 2 3 4 5", iree::span<int8_t>(buffer4)),
StatusIs(StatusCode::kOutOfRange));
}
diff --git a/iree/modules/check/BUILD b/iree/modules/check/BUILD
index 37191ba..20caac1 100644
--- a/iree/modules/check/BUILD
+++ b/iree/modules/check/BUILD
@@ -19,6 +19,7 @@
"//iree/base:logging",
"//iree/base:status",
"//iree/base/internal",
+ "//iree/base/internal:span",
"//iree/hal",
"//iree/hal/vmvx/registration",
"//iree/modules/hal",
@@ -27,7 +28,6 @@
"//iree/vm",
"//iree/vm:bytecode_module",
"//iree/vm:cc",
- "@com_google_absl//absl/types:span",
],
)
@@ -45,6 +45,5 @@
"//iree/testing:gtest",
"//iree/vm",
"//iree/vm:cc",
- "@com_google_absl//absl/types:span",
],
)
diff --git a/iree/modules/check/CMakeLists.txt b/iree/modules/check/CMakeLists.txt
index 12a54ad..f391497 100644
--- a/iree/modules/check/CMakeLists.txt
+++ b/iree/modules/check/CMakeLists.txt
@@ -15,9 +15,9 @@
"check_test.cc"
DEPS
::native_module
- absl::span
iree::base
iree::base::internal
+ iree::base::internal::span
iree::base::logging
iree::base::status
iree::hal
diff --git a/iree/modules/check/check_test.cc b/iree/modules/check/check_test.cc
index 138d417..7fb551c 100644
--- a/iree/modules/check/check_test.cc
+++ b/iree/modules/check/check_test.cc
@@ -10,9 +10,9 @@
#include <cstdint>
#include <vector>
-#include "absl/types/span.h"
#include "iree/base/api.h"
#include "iree/base/internal/math.h"
+#include "iree/base/internal/span.h"
#include "iree/base/logging.h"
#include "iree/base/status.h"
#include "iree/hal/api.h"
@@ -73,8 +73,8 @@
iree_vm_context_release(context_);
}
- void CreateInt32BufferView(absl::Span<const int32_t> contents,
- absl::Span<const int32_t> shape,
+ void CreateInt32BufferView(iree::span<const int32_t> contents,
+ iree::span<const int32_t> shape,
iree_hal_buffer_view_t** out_buffer_view) {
size_t num_elements = 1;
for (int32_t dim : shape) {
@@ -95,8 +95,8 @@
&*out_buffer_view));
}
- void CreateFloat16BufferView(absl::Span<const uint16_t> contents,
- absl::Span<const int32_t> shape,
+ void CreateFloat16BufferView(iree::span<const uint16_t> contents,
+ iree::span<const int32_t> shape,
iree_hal_buffer_view_t** out_buffer_view) {
size_t num_elements = 1;
for (int32_t dim : shape) {
@@ -118,8 +118,8 @@
IREE_HAL_ELEMENT_TYPE_FLOAT_16, &*out_buffer_view));
}
- void CreateFloat32BufferView(absl::Span<const float> contents,
- absl::Span<const int32_t> shape,
+ void CreateFloat32BufferView(iree::span<const float> contents,
+ iree::span<const int32_t> shape,
iree_hal_buffer_view_t** out_buffer_view) {
size_t num_elements = 1;
for (int32_t dim : shape) {
@@ -140,8 +140,8 @@
IREE_HAL_ELEMENT_TYPE_FLOAT_32, &*out_buffer_view));
}
- void CreateFloat64BufferView(absl::Span<const double> contents,
- absl::Span<const int32_t> shape,
+ void CreateFloat64BufferView(iree::span<const double> contents,
+ iree::span<const int32_t> shape,
iree_hal_buffer_view_t** out_buffer_view) {
size_t num_elements = 1;
for (int32_t dim : shape) {
diff --git a/iree/modules/check/native_module.cc b/iree/modules/check/native_module.cc
index 3f83806..b1dcfe2 100644
--- a/iree/modules/check/native_module.cc
+++ b/iree/modules/check/native_module.cc
@@ -17,7 +17,6 @@
#include <utility>
#include <vector>
-#include "absl/types/span.h"
#include "iree/base/api.h"
#include "iree/base/internal/math.h"
#include "iree/base/status.h"
@@ -38,9 +37,9 @@
using ::testing::Not;
template <typename T>
-absl::Span<const T> AbslSpan(iree_byte_span_t bytes) {
- return absl::Span<T>(reinterpret_cast<T*>(bytes.data),
- bytes.data_length / sizeof(T));
+iree::span<const T> ToSpan(iree_byte_span_t bytes) {
+ return iree::span<const T>(reinterpret_cast<T*>(bytes.data),
+ bytes.data_length / sizeof(T));
}
StatusOr<std::string> BufferViewToString(iree_hal_buffer_view_t* buffer_view) {
@@ -59,21 +58,21 @@
template <typename T>
Status ExpectAllTrue(iree_byte_span_t bytes) {
- EXPECT_THAT(AbslSpan<T>(bytes), Each(Not(T(0))));
+ EXPECT_THAT(ToSpan<T>(bytes), Each(Not(T(0))));
return OkStatus();
}
-// TODO(b/146898896): Put this somewhere common. Operator overload?
bool EqByteSpan(iree_byte_span_t lhs_bytes, iree_byte_span_t rhs_bytes) {
- return AbslSpan<uint8_t>(lhs_bytes) == AbslSpan<uint8_t>(rhs_bytes);
+ return lhs_bytes.data_length == rhs_bytes.data_length &&
+ memcmp(lhs_bytes.data, rhs_bytes.data, lhs_bytes.data_length) == 0;
}
static constexpr float kF32PrecisionThreshold = 0.0001f;
template <typename T>
bool AlmostEqByteSpan(iree_byte_span_t lhs_bytes, iree_byte_span_t rhs_bytes) {
- auto lhs_span = AbslSpan<T>(lhs_bytes);
- auto rhs_span = AbslSpan<T>(rhs_bytes);
+ auto lhs_span = ToSpan<T>(lhs_bytes);
+ auto rhs_span = ToSpan<T>(rhs_bytes);
assert(lhs_span.size() == rhs_span.size());
for (int i = 0; i < lhs_span.size(); ++i) {
if (fabs(lhs_span[i] - rhs_span[i]) > kF32PrecisionThreshold) {
@@ -87,8 +86,8 @@
bool AlmostEqByteSpanF16(iree_byte_span_t lhs_bytes,
iree_byte_span_t rhs_bytes) {
- auto lhs_span = AbslSpan<uint16_t>(lhs_bytes);
- auto rhs_span = AbslSpan<uint16_t>(rhs_bytes);
+ auto lhs_span = ToSpan<uint16_t>(lhs_bytes);
+ auto rhs_span = ToSpan<uint16_t>(rhs_bytes);
assert(lhs_span.size() == rhs_span.size());
for (int i = 0; i < lhs_span.size(); ++i) {
if (fabs(iree_math_f16_to_f32(lhs_span[i]) -
@@ -414,7 +413,9 @@
IREE_ASSERT_ARGUMENT(out_module);
*out_module = NULL;
auto module = std::make_unique<CheckModule>(
- "check", allocator, absl::MakeConstSpan(kCheckModuleFunctions));
+ "check", allocator,
+ iree::span<const vm::NativeFunction<CheckModuleState>>(
+ kCheckModuleFunctions));
*out_module = module.release()->interface();
return iree_ok_status();
}
diff --git a/iree/samples/custom_modules/BUILD b/iree/samples/custom_modules/BUILD
index 4976f64..e22b356 100644
--- a/iree/samples/custom_modules/BUILD
+++ b/iree/samples/custom_modules/BUILD
@@ -63,6 +63,5 @@
"//iree/modules/hal",
"//iree/vm",
"//iree/vm:cc",
- "@com_google_absl//absl/types:span",
],
)
diff --git a/iree/samples/custom_modules/CMakeLists.txt b/iree/samples/custom_modules/CMakeLists.txt
index b5316ed..df83ea1 100644
--- a/iree/samples/custom_modules/CMakeLists.txt
+++ b/iree/samples/custom_modules/CMakeLists.txt
@@ -58,7 +58,6 @@
SRCS
"native_module.cc"
DEPS
- absl::span
iree::base
iree::base::status
iree::hal
diff --git a/iree/samples/custom_modules/native_module.cc b/iree/samples/custom_modules/native_module.cc
index 3d22621..9aff5db 100644
--- a/iree/samples/custom_modules/native_module.cc
+++ b/iree/samples/custom_modules/native_module.cc
@@ -15,7 +15,6 @@
#include <type_traits>
#include <utility>
-#include "absl/types/span.h"
#include "iree/base/api.h"
#include "iree/base/status.h"
#include "iree/hal/api.h"
@@ -285,7 +284,9 @@
IREE_ASSERT_ARGUMENT(out_module);
*out_module = NULL;
auto module = std::make_unique<CustomModule>(
- "custom", allocator, absl::MakeConstSpan(kCustomModuleFunctions));
+ "custom", allocator,
+ iree::span<const vm::NativeFunction<CustomModuleState>>(
+ kCustomModuleFunctions));
IREE_RETURN_IF_ERROR(module->Initialize());
*out_module = module.release()->interface();
return iree_ok_status();
diff --git a/iree/samples/vulkan/CMakeLists.txt b/iree/samples/vulkan/CMakeLists.txt
index 2f1ce48..fccf6ab 100644
--- a/iree/samples/vulkan/CMakeLists.txt
+++ b/iree/samples/vulkan/CMakeLists.txt
@@ -37,7 +37,6 @@
SRCS
"vulkan_inference_gui.cc"
DEPS
- absl::base
iree::base::internal::main
iree::hal::vulkan::registration
iree::modules::hal
diff --git a/iree/test/BUILD b/iree/test/BUILD
index 019314f..236a474 100644
--- a/iree/test/BUILD
+++ b/iree/test/BUILD
@@ -4,20 +4,8 @@
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-load("//iree:build_defs.oss.bzl", "iree_cmake_extra_content")
-
package(
default_visibility = ["//visibility:public"],
features = ["layering_check"],
licenses = ["notice"], # Apache 2.0
)
-
-iree_cmake_extra_content(
- content = """
-# TODO(#3848): Test tools has implicit thread dependency from absl.
-if(NOT ${IREE_ENABLE_THREADING})
- return()
-endif()
-""",
- inline = True,
-)
diff --git a/iree/test/CMakeLists.txt b/iree/test/CMakeLists.txt
index 189818e..9f758b5 100644
--- a/iree/test/CMakeLists.txt
+++ b/iree/test/CMakeLists.txt
@@ -10,9 +10,4 @@
iree_add_all_subdirs()
-# TODO(#3848): Test tools has implicit thread dependency from absl.
-if(NOT ${IREE_ENABLE_THREADING})
- return()
-endif()
-
### BAZEL_TO_CMAKE_PRESERVES_ALL_CONTENT_BELOW_THIS_LINE ###
diff --git a/iree/testing/BUILD b/iree/testing/BUILD
index 42e2803..4c0040c 100644
--- a/iree/testing/BUILD
+++ b/iree/testing/BUILD
@@ -6,8 +6,6 @@
# Testing utilities for IREE.
-load("//iree:build_defs.oss.bzl", "iree_cmake_extra_content")
-
package(
default_visibility = ["//visibility:public"],
features = ["layering_check"],
@@ -40,16 +38,6 @@
],
)
-iree_cmake_extra_content(
- content = """
-# TODO(#3848): gtest library has implicit thread dependency from absl.
-if(NOT ${IREE_ENABLE_THREADING})
- return()
-endif()
-""",
- inline = True,
-)
-
cc_library(
name = "gtest",
testonly = True,
@@ -59,8 +47,6 @@
],
deps = [
"//iree/base:status",
- "@com_google_absl//absl/strings",
- "@com_google_absl//absl/types:optional",
"@com_google_googletest//:gtest",
],
)
diff --git a/iree/testing/CMakeLists.txt b/iree/testing/CMakeLists.txt
index 12b0c32..ed08889 100644
--- a/iree/testing/CMakeLists.txt
+++ b/iree/testing/CMakeLists.txt
@@ -37,11 +37,6 @@
PUBLIC
)
-# TODO(#3848): gtest library has implicit thread dependency from absl.
-if(NOT ${IREE_ENABLE_THREADING})
- return()
-endif()
-
iree_cc_library(
NAME
gtest
@@ -49,8 +44,6 @@
"gtest.h"
"status_matchers.h"
DEPS
- absl::optional
- absl::strings
gmock
gtest
iree::base::status
diff --git a/iree/testing/status_matchers.h b/iree/testing/status_matchers.h
index dc56f87..36b0d29 100644
--- a/iree/testing/status_matchers.h
+++ b/iree/testing/status_matchers.h
@@ -8,9 +8,8 @@
#define IREE_TESTING_STATUS_MATCHERS_H_
#include <memory>
+#include <string>
-#include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
#include "iree/base/status.h" // IWYU pragma: export
#include "iree/testing/gtest.h"
@@ -93,16 +92,16 @@
template <typename Enum, typename Matchee>
class StatusMatcher : public ::testing::MatcherInterface<Matchee> {
public:
- StatusMatcher(Enum code, absl::optional<absl::string_view> message)
- : code_(code), message_(message) {}
+ StatusMatcher(Enum code, std::string message)
+ : code_(code), message_(std::move(message)) {}
// From testing::MatcherInterface.
//
// Describes the expected error code.
void DescribeTo(std::ostream *os) const override {
*os << "error code " << StatusCodeToString(code_);
- if (message_.has_value()) {
- *os << "::'" << message_.value() << "'";
+ if (!message_.empty()) {
+ *os << "::'" << message_ << "'";
}
}
@@ -121,7 +120,7 @@
<< GetMessage(matchee);
return false;
}
- if (message_.has_value() && GetMessage(matchee) != message_.value()) {
+ if (!message_.empty() && GetMessage(matchee) != message_) {
*listener << "whose error message is '" << GetMessage(matchee) << "'";
return false;
}
@@ -161,7 +160,7 @@
const Enum code_;
// Expected error message (empty if none expected and verified).
- const absl::optional<std::string> message_;
+ const std::string message_;
};
// StatusMatcherGenerator is an intermediate object returned by
@@ -173,8 +172,8 @@
template <typename Enum>
class StatusIsMatcherGenerator {
public:
- StatusIsMatcherGenerator(Enum code, absl::optional<absl::string_view> message)
- : code_(code), message_(message) {}
+ StatusIsMatcherGenerator(Enum code, std::string message)
+ : code_(code), message_(std::move(message)) {}
operator ::testing::Matcher<const StatusCode &>() const {
return ::testing::MakeMatcher(
@@ -204,7 +203,7 @@
const Enum code_;
// Expected error message (empty if none expected and verified).
- const absl::optional<std::string> message_;
+ const std::string message_;
};
// Implements a gMock matcher that checks whether a status container (e.g.
@@ -296,15 +295,15 @@
// given |code|.
template <typename Enum>
internal::StatusIsMatcherGenerator<Enum> StatusIs(Enum code) {
- return internal::StatusIsMatcherGenerator<Enum>(code, absl::nullopt);
+ return internal::StatusIsMatcherGenerator<Enum>(code, "");
}
// Returns a gMock matcher that expects an iree::Status object to have the
// given |code| and |message|.
template <typename Enum>
internal::StatusIsMatcherGenerator<Enum> StatusIs(Enum code,
- absl::string_view message) {
- return internal::StatusIsMatcherGenerator<Enum>(code, message);
+ std::string message) {
+ return internal::StatusIsMatcherGenerator<Enum>(code, std::move(message));
}
// Returns an internal::IsOkMatcherGenerator, which may be typecast to a
diff --git a/iree/testing/vulkan/iree-run-module-vulkan-gui-main.cc b/iree/testing/vulkan/iree-run-module-vulkan-gui-main.cc
index 9ecd42b..7098cf6 100644
--- a/iree/testing/vulkan/iree-run-module-vulkan-gui-main.cc
+++ b/iree/testing/vulkan/iree-run-module-vulkan-gui-main.cc
@@ -159,7 +159,7 @@
}
// Setup window
- SDL_WindowFlags window_flags = (SDL_WindowFlags)(
+ SDL_WindowFlags window_flags = (SDL_WindowFlags)( //
SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
SDL_Window* window = SDL_CreateWindow(
"IREE Samples - Vulkan Inference GUI", SDL_WINDOWPOS_CENTERED,
@@ -338,9 +338,11 @@
<< "'";
vm::ref<iree_vm_list_t> main_function_inputs;
- IREE_CHECK_OK(ParseToVariantList(iree_hal_device_allocator(iree_vk_device),
- FLAG_function_inputs,
- &main_function_inputs));
+ IREE_CHECK_OK(ParseToVariantList(
+ iree_hal_device_allocator(iree_vk_device),
+ iree::span<const std::string>{FLAG_function_inputs.data(),
+ FLAG_function_inputs.size()},
+ &main_function_inputs));
const std::string window_title = std::string(FLAG_module_file);
// --------------------------------------------------------------------------
diff --git a/iree/tools/BUILD b/iree/tools/BUILD
index 4b37264..e352642 100644
--- a/iree/tools/BUILD
+++ b/iree/tools/BUILD
@@ -262,7 +262,6 @@
"//iree/vm",
"//iree/vm:bytecode_module",
"//iree/vm:cc",
- "@com_google_absl//absl/types:span",
"@llvm-project//llvm:Support",
"@llvm-project//mlir:IR",
"@llvm-project//mlir:LLVMToLLVMIRTranslation",
@@ -289,7 +288,6 @@
"//iree/vm",
"//iree/vm:bytecode_module",
"//iree/vm:cc",
- "@com_google_absl//absl/strings",
],
)
diff --git a/iree/tools/CMakeLists.txt b/iree/tools/CMakeLists.txt
index b4e3c12..ebd07e7 100644
--- a/iree/tools/CMakeLists.txt
+++ b/iree/tools/CMakeLists.txt
@@ -6,7 +6,7 @@
# Doesn't use bazel_to_cmake because of various special logic throughout.
-# Tools has thread dependency from iree::hal::drivers and absl
+# Tools has thread dependency from iree::hal::drivers
if(NOT ${IREE_ENABLE_THREADING})
return()
endif()
@@ -84,8 +84,6 @@
SRCS
"iree-check-module-main.cc"
DEPS
- iree::modules::check::native_module
- absl::strings
iree::base
iree::base::core_headers
iree::base::internal::file_io
@@ -95,6 +93,7 @@
iree::base::tracing
iree::hal
iree::hal::drivers
+ iree::modules::check::native_module
iree::modules::hal
iree::testing::gtest
iree::tools::utils::vm_util
@@ -369,7 +368,6 @@
MLIRPass
MLIRSupport
MLIRTargetLLVMIRExport
- absl::span
iree::base
iree::base::internal::flags
iree::base::logging
diff --git a/iree/tools/android/run_module_app/CMakeLists.txt b/iree/tools/android/run_module_app/CMakeLists.txt
index 7a3fb32..f1e7c1d 100644
--- a/iree/tools/android/run_module_app/CMakeLists.txt
+++ b/iree/tools/android/run_module_app/CMakeLists.txt
@@ -31,7 +31,6 @@
${NATIVE_APP_GLUE_DIR}
DEPS
::android_native_app_glue
- absl::strings
iree::base::status
iree::hal::drivers
iree::modules::hal
diff --git a/iree/tools/android/run_module_app/src/main.cc b/iree/tools/android/run_module_app/src/main.cc
index 9a6acd8..39b3368 100644
--- a/iree/tools/android/run_module_app/src/main.cc
+++ b/iree/tools/android/run_module_app/src/main.cc
@@ -9,15 +9,15 @@
#include <array>
#include <chrono>
+#include <string>
#include <thread>
-#include "absl/strings/str_split.h"
-#include "absl/strings/string_view.h"
#include "iree/base/status.h"
#include "iree/hal/drivers/init.h"
#include "iree/modules/hal/hal_module.h"
#include "iree/tools/utils/vm_util.h"
#include "iree/vm/api.h"
+#include "iree/vm/bytecode_module.h"
namespace iree {
namespace {
@@ -96,12 +96,16 @@
"creating instance");
iree_vm_module_t* input_module = nullptr;
- IREE_RETURN_IF_ERROR(LoadBytecodeModule(invocation.module, &input_module));
+ IREE_RETURN_IF_ERROR(iree_vm_bytecode_module_create(
+ iree_make_const_byte_span((void*)invocation.module.data(),
+ invocation.module.size()),
+ iree_allocator_null(), iree_allocator_system(), &input_module));
iree_hal_device_t* device = nullptr;
IREE_RETURN_IF_ERROR(CreateDevice(invocation.driver.c_str(), &device));
iree_vm_module_t* hal_module = nullptr;
- IREE_RETURN_IF_ERROR(CreateHalModule(device, &hal_module));
+ IREE_RETURN_IF_ERROR(
+ iree_hal_module_create(device, iree_allocator_system(), &hal_module));
iree_vm_context_t* context = nullptr;
// Order matters. The input module will likely be dependent on the hal module.
@@ -120,8 +124,13 @@
&function),
"looking up function '%s'", function_name.c_str());
- std::vector<absl::string_view> input_views(
- absl::StrSplit(invocation.inputs, '\n', absl::SkipEmpty()));
+ size_t pos = 0;
+ std::string inputs_str = invocation.inputs;
+ std::vector<std::string> input_views;
+ while ((pos = inputs_str.find('\n')) != std::string::npos) {
+ input_views.push_back(inputs_str.substr(0, pos));
+ inputs_str.erase(0, pos + 1);
+ }
vm::ref<iree_vm_list_t> inputs;
IREE_RETURN_IF_ERROR(ParseToVariantList(iree_hal_device_allocator(device),
input_views, &inputs));
diff --git a/iree/tools/iree-benchmark-module-main.cc b/iree/tools/iree-benchmark-module-main.cc
index 307ea23..1c2f572 100644
--- a/iree/tools/iree-benchmark-module-main.cc
+++ b/iree/tools/iree-benchmark-module-main.cc
@@ -24,6 +24,7 @@
#include "iree/modules/hal/hal_module.h"
#include "iree/tools/utils/vm_util.h"
#include "iree/vm/api.h"
+#include "iree/vm/bytecode_module.h"
#include "iree/vm/ref_cc.h"
IREE_FLAG(string, module_file, "-",
@@ -188,8 +189,12 @@
// Create IREE's device and module.
IREE_RETURN_IF_ERROR(iree::CreateDevice(FLAG_driver, &device_));
- IREE_RETURN_IF_ERROR(CreateHalModule(device_, &hal_module_));
- IREE_RETURN_IF_ERROR(LoadBytecodeModule(module_data_, &input_module_));
+ IREE_RETURN_IF_ERROR(
+ iree_hal_module_create(device_, iree_allocator_system(), &hal_module_));
+ IREE_RETURN_IF_ERROR(iree_vm_bytecode_module_create(
+ iree_make_const_byte_span((void*)module_data_.data(),
+ module_data_.size()),
+ iree_allocator_null(), iree_allocator_system(), &input_module_));
// Order matters. The input module will likely be dependent on the hal
// module.
@@ -211,8 +216,11 @@
iree_string_view_t{function_name.data(), function_name.size()},
&function));
- IREE_CHECK_OK(ParseToVariantList(iree_hal_device_allocator(device_),
- FLAG_function_inputs, &inputs_));
+ IREE_CHECK_OK(ParseToVariantList(
+ iree_hal_device_allocator(device_),
+ iree::span<const std::string>{FLAG_function_inputs.data(),
+ FLAG_function_inputs.size()},
+ &inputs_));
RegisterModuleBenchmarks(function_name, context_, function, inputs_.get());
return iree_ok_status();
}
diff --git a/iree/tools/iree-check-module-main.cc b/iree/tools/iree-check-module-main.cc
index c9f16d8..c38be3a 100644
--- a/iree/tools/iree-check-module-main.cc
+++ b/iree/tools/iree-check-module-main.cc
@@ -27,6 +27,7 @@
#include "iree/testing/status_matchers.h"
#include "iree/tools/utils/vm_util.h"
#include "iree/vm/api.h"
+#include "iree/vm/bytecode_module.h"
// On Windows stdin defaults to text mode and will get weird line ending
// expansion that will corrupt the input binary.
@@ -99,12 +100,15 @@
}
iree_vm_module_t* input_module = nullptr;
- IREE_RETURN_IF_ERROR(LoadBytecodeModule(module_data, &input_module));
+ IREE_RETURN_IF_ERROR(iree_vm_bytecode_module_create(
+ iree_make_const_byte_span((void*)module_data.data(), module_data.size()),
+ iree_allocator_null(), iree_allocator_system(), &input_module));
iree_hal_device_t* device = nullptr;
IREE_RETURN_IF_ERROR(CreateDevice(FLAG_driver, &device));
iree_vm_module_t* hal_module = nullptr;
- IREE_RETURN_IF_ERROR(CreateHalModule(device, &hal_module));
+ IREE_RETURN_IF_ERROR(
+ iree_hal_module_create(device, iree_allocator_system(), &hal_module));
iree_vm_module_t* check_module = nullptr;
check_native_module_create(iree_allocator_system(), &check_module);
diff --git a/iree/tools/iree-run-mlir-main.cc b/iree/tools/iree-run-mlir-main.cc
index 7f079c6..35f5fb0 100644
--- a/iree/tools/iree-run-mlir-main.cc
+++ b/iree/tools/iree-run-mlir-main.cc
@@ -38,7 +38,6 @@
#include <utility>
#include <vector>
-#include "absl/types/span.h"
#include "iree/base/api.h"
#include "iree/base/internal/flags.h"
#include "iree/base/logging.h"
@@ -56,6 +55,7 @@
#include "iree/tools/init_targets.h"
#include "iree/tools/utils/vm_util.h"
#include "iree/vm/api.h"
+#include "iree/vm/bytecode_module.h"
#include "iree/vm/ref_cc.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
@@ -270,7 +270,7 @@
// Parse input values from the flags.
vm::ref<iree_vm_list_t> inputs;
- auto function_inputs_list = absl::MakeConstSpan(
+ auto function_inputs_list = iree::span<std::string>(
function_inputs_flag.empty() ? nullptr : &function_inputs_flag.front(),
function_inputs_flag.size());
IREE_RETURN_IF_ERROR(
@@ -305,7 +305,10 @@
// We do this first so that if we fail validation we know prior to dealing
// with devices.
iree_vm_module_t* bytecode_module = nullptr;
- IREE_RETURN_IF_ERROR(LoadBytecodeModule(flatbuffer_data, &bytecode_module));
+ IREE_RETURN_IF_ERROR(iree_vm_bytecode_module_create(
+ iree_make_const_byte_span((void*)flatbuffer_data.data(),
+ flatbuffer_data.size()),
+ iree_allocator_null(), iree_allocator_system(), &bytecode_module));
if (!run_flag) {
// Just wanted verification; return without running.
@@ -316,7 +319,8 @@
iree_hal_device_t* device = nullptr;
IREE_RETURN_IF_ERROR(CreateDevice(driver_name.c_str(), &device));
iree_vm_module_t* hal_module = nullptr;
- IREE_RETURN_IF_ERROR(CreateHalModule(device, &hal_module));
+ IREE_RETURN_IF_ERROR(
+ iree_hal_module_create(device, iree_allocator_system(), &hal_module));
// Evaluate all exported functions.
auto run_function = [&](int ordinal) -> Status {
@@ -467,14 +471,14 @@
int argc_llvm = argc;
char** argv_llvm = argv;
- int argc_absl = 1;
- std::vector<char*> argv_absl = {argv[0]};
+ int argc_iree = 1;
+ std::vector<char*> argv_iree = {argv[0]};
for (int i = 0; i < argc; ++i) {
if (std::strcmp(argv[i], "--") == 0) {
argc_llvm = i;
- argc_absl = argc - i;
+ argc_iree = argc - i;
for (int j = i + 1; j < argc; ++j) {
- argv_absl.push_back(argv[i + 1]);
+ argv_iree.push_back(argv[i + 1]);
}
break;
}
@@ -502,12 +506,12 @@
llvm::cl::ParseCommandLineOptions(argc_llvm, argv_llvm);
for (auto& run_arg : run_args_flag) {
- argv_absl.push_back(const_cast<char*>(run_arg.c_str()));
+ argv_iree.push_back(const_cast<char*>(run_arg.c_str()));
}
- argc_absl += run_args_flag.size();
- char** argv_absl_ptr = argv_absl.data();
- iree_flags_parse_checked(IREE_FLAGS_PARSE_MODE_DEFAULT, &argc_absl,
- &argv_absl_ptr);
+ argc_iree += run_args_flag.size();
+ char** argv_iree_ptr = argv_iree.data();
+ iree_flags_parse_checked(IREE_FLAGS_PARSE_MODE_DEFAULT, &argc_iree,
+ &argv_iree_ptr);
IREE_CHECK_OK(iree_hal_register_all_available_drivers(
iree_hal_driver_registry_default()));
diff --git a/iree/tools/iree-run-module-main.cc b/iree/tools/iree-run-module-main.cc
index 4dd04ab..c303ac8 100644
--- a/iree/tools/iree-run-module-main.cc
+++ b/iree/tools/iree-run-module-main.cc
@@ -22,6 +22,7 @@
#include "iree/modules/hal/hal_module.h"
#include "iree/tools/utils/vm_util.h"
#include "iree/vm/api.h"
+#include "iree/vm/bytecode_module.h"
#include "iree/vm/ref_cc.h"
IREE_FLAG(string, module_file, "-",
@@ -93,12 +94,15 @@
std::string module_data;
IREE_RETURN_IF_ERROR(GetModuleContentsFromFlags(&module_data));
iree_vm_module_t* input_module = nullptr;
- IREE_RETURN_IF_ERROR(LoadBytecodeModule(module_data, &input_module));
+ IREE_RETURN_IF_ERROR(iree_vm_bytecode_module_create(
+ iree_make_const_byte_span((void*)module_data.data(), module_data.size()),
+ iree_allocator_null(), iree_allocator_system(), &input_module));
iree_hal_device_t* device = nullptr;
IREE_RETURN_IF_ERROR(CreateDevice(FLAG_driver, &device));
iree_vm_module_t* hal_module = nullptr;
- IREE_RETURN_IF_ERROR(CreateHalModule(device, &hal_module));
+ IREE_RETURN_IF_ERROR(
+ iree_hal_module_create(device, iree_allocator_system(), &hal_module));
iree_vm_context_t* context = nullptr;
// Order matters. The input module will likely be dependent on the hal module.
@@ -123,8 +127,11 @@
}
vm::ref<iree_vm_list_t> inputs;
- IREE_CHECK_OK(ParseToVariantList(iree_hal_device_allocator(device),
- FLAG_function_inputs, &inputs));
+ IREE_CHECK_OK(ParseToVariantList(
+ iree_hal_device_allocator(device),
+ iree::span<const std::string>{FLAG_function_inputs.data(),
+ FLAG_function_inputs.size()},
+ &inputs));
vm::ref<iree_vm_list_t> outputs;
IREE_RETURN_IF_ERROR(iree_vm_list_create(/*element_type=*/nullptr, 16,
diff --git a/iree/tools/utils/BUILD b/iree/tools/utils/BUILD
index 5294ca4..5875944 100644
--- a/iree/tools/utils/BUILD
+++ b/iree/tools/utils/BUILD
@@ -21,13 +21,12 @@
"//iree/base:status",
"//iree/base:tracing",
"//iree/base/internal:file_io",
+ "//iree/base/internal:span",
"//iree/hal",
"//iree/modules/hal",
"//iree/vm",
"//iree/vm:bytecode_module",
"//iree/vm:cc",
- "@com_google_absl//absl/strings",
- "@com_google_absl//absl/types:span",
],
)
@@ -44,6 +43,5 @@
"//iree/testing:gtest_main",
"//iree/vm",
"//iree/vm:cc",
- "@com_google_absl//absl/strings",
],
)
diff --git a/iree/tools/utils/CMakeLists.txt b/iree/tools/utils/CMakeLists.txt
index 2df8a9e..4dd9544 100644
--- a/iree/tools/utils/CMakeLists.txt
+++ b/iree/tools/utils/CMakeLists.txt
@@ -18,10 +18,9 @@
SRCS
"vm_util.cc"
DEPS
- absl::span
- absl::strings
iree::base
iree::base::internal::file_io
+ iree::base::internal::span
iree::base::logging
iree::base::status
iree::base::tracing
@@ -40,7 +39,6 @@
"vm_util_test.cc"
DEPS
::vm_util
- absl::strings
iree::base
iree::hal
iree::hal::vmvx::registration
diff --git a/iree/tools/utils/vm_util.cc b/iree/tools/utils/vm_util.cc
index 4361006..cae61c5 100644
--- a/iree/tools/utils/vm_util.cc
+++ b/iree/tools/utils/vm_util.cc
@@ -13,8 +13,6 @@
#include <type_traits>
#include <vector>
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
#include "iree/base/api.h"
#include "iree/base/internal/file_io.h"
#include "iree/base/logging.h"
@@ -22,7 +20,6 @@
#include "iree/base/tracing.h"
#include "iree/hal/api.h"
#include "iree/modules/hal/hal_module.h"
-#include "iree/vm/bytecode_module.h"
#include "iree/vm/ref_cc.h"
namespace iree {
@@ -72,7 +69,7 @@
}
Status ParseToVariantList(iree_hal_allocator_t* allocator,
- absl::Span<const absl::string_view> input_strings,
+ iree::span<const std::string> input_strings,
iree_vm_list_t** out_list) {
*out_list = NULL;
vm::ref<iree_vm_list_t> variant_list;
@@ -124,16 +121,6 @@
return OkStatus();
}
-Status ParseToVariantList(iree_hal_allocator_t* allocator,
- absl::Span<const std::string> input_strings,
- iree_vm_list_t** out_list) {
- std::vector<absl::string_view> input_views(input_strings.size());
- for (int i = 0; i < input_strings.size(); ++i) {
- input_views[i] = input_strings[i];
- }
- return ParseToVariantList(allocator, input_views, out_list);
-}
-
Status PrintVariantList(iree_vm_list_t* variant_list, std::ostream* os) {
for (iree_host_size_t i = 0; i < iree_vm_list_size(variant_list); ++i) {
iree_vm_variant_t variant = iree_vm_variant_empty();
@@ -209,23 +196,4 @@
return OkStatus();
}
-Status CreateHalModule(iree_hal_device_t* device,
- iree_vm_module_t** out_module) {
- IREE_RETURN_IF_ERROR(
- iree_hal_module_create(device, iree_allocator_system(), out_module),
- "creating HAL module");
- return OkStatus();
-}
-
-Status LoadBytecodeModule(absl::string_view module_data,
- iree_vm_module_t** out_module) {
- IREE_RETURN_IF_ERROR(
- iree_vm_bytecode_module_create(
- iree_const_byte_span_t{
- reinterpret_cast<const uint8_t*>(module_data.data()),
- module_data.size()},
- iree_allocator_null(), iree_allocator_system(), out_module),
- "deserializing module");
- return OkStatus();
-}
} // namespace iree
diff --git a/iree/tools/utils/vm_util.h b/iree/tools/utils/vm_util.h
index 0678c19..1d1d6ee 100644
--- a/iree/tools/utils/vm_util.h
+++ b/iree/tools/utils/vm_util.h
@@ -12,8 +12,7 @@
#include <string>
#include <vector>
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
+#include "iree/base/internal/span.h"
#include "iree/base/status.h"
#include "iree/hal/api.h"
#include "iree/vm/api.h"
@@ -36,10 +35,7 @@
// Uses descriptors in |descs| for type information and validation.
// The returned variant list must be freed by the caller.
Status ParseToVariantList(iree_hal_allocator_t* allocator,
- absl::Span<const absl::string_view> input_strings,
- iree_vm_list_t** out_list);
-Status ParseToVariantList(iree_hal_allocator_t* allocator,
- absl::Span<const std::string> input_strings,
+ iree::span<const std::string> input_strings,
iree_vm_list_t** out_list);
// Prints a variant list of VM scalars and buffers to |os|.
@@ -57,16 +53,6 @@
// The returned |out_device| must be released by the caller.
Status CreateDevice(const char* driver_name, iree_hal_device_t** out_device);
-// Creates a hal module |driver| in |out_hal_module|.
-// The returned |out_module| must be released by the caller.
-Status CreateHalModule(iree_hal_device_t* device,
- iree_vm_module_t** out_module);
-
-// Loads a VM bytecode from an opaque string.
-// The returned |out_module| must be released by the caller.
-Status LoadBytecodeModule(absl::string_view module_data,
- iree_vm_module_t** out_module);
-
} // namespace iree
#endif // IREE_TOOLS_UTILS_VM_UTIL_H_
diff --git a/iree/tools/utils/vm_util_test.cc b/iree/tools/utils/vm_util_test.cc
index b897e2c..e9fdb82 100644
--- a/iree/tools/utils/vm_util_test.cc
+++ b/iree/tools/utils/vm_util_test.cc
@@ -6,7 +6,6 @@
#include "iree/tools/utils/vm_util.h"
-#include "absl/strings/str_cat.h"
#include "iree/base/api.h"
#include "iree/hal/api.h"
#include "iree/hal/vmvx/registration/driver_module.h"
@@ -39,45 +38,49 @@
};
TEST_F(VmUtilTest, ParsePrintBuffer) {
- absl::string_view buf_string = "2x2xi32=[42 43][44 45]";
+ std::string buf_string = "2x2xi32=[42 43][44 45]";
vm::ref<iree_vm_list_t> variant_list;
- IREE_ASSERT_OK(ParseToVariantList(allocator_, {buf_string}, &variant_list));
+ IREE_ASSERT_OK(ParseToVariantList(
+ allocator_, std::vector<std::string>{buf_string}, &variant_list));
std::stringstream os;
IREE_ASSERT_OK(PrintVariantList(variant_list.get(), &os));
EXPECT_EQ(os.str(),
- absl::StrCat("result[0]: hal.buffer_view\n", buf_string, "\n"));
+ std::string("result[0]: hal.buffer_view\n") + buf_string + "\n");
}
TEST_F(VmUtilTest, ParsePrintScalar) {
- absl::string_view input_string = "42";
+ std::string input_string = "42";
vm::ref<iree_vm_list_t> variant_list;
- IREE_ASSERT_OK(ParseToVariantList(allocator_, {input_string}, &variant_list));
+ IREE_ASSERT_OK(ParseToVariantList(
+ allocator_, std::vector<std::string>{input_string}, &variant_list));
std::stringstream os;
IREE_ASSERT_OK(PrintVariantList(variant_list.get(), &os));
- EXPECT_EQ(os.str(), absl::StrCat("result[0]: i32=", input_string, "\n"));
+ EXPECT_EQ(os.str(), std::string("result[0]: i32=") + input_string + "\n");
}
TEST_F(VmUtilTest, ParsePrintRank0Buffer) {
- absl::string_view buf_string = "i32=42";
+ std::string buf_string = "i32=42";
vm::ref<iree_vm_list_t> variant_list;
- IREE_ASSERT_OK(ParseToVariantList(allocator_, {buf_string}, &variant_list));
+ IREE_ASSERT_OK(ParseToVariantList(
+ allocator_, std::vector<std::string>{buf_string}, &variant_list));
std::stringstream os;
IREE_ASSERT_OK(PrintVariantList(variant_list.get(), &os));
EXPECT_EQ(os.str(),
- absl::StrCat("result[0]: hal.buffer_view\n", buf_string, "\n"));
+ std::string("result[0]: hal.buffer_view\n") + buf_string + "\n");
}
TEST_F(VmUtilTest, ParsePrintMultipleBuffers) {
- absl::string_view buf_string1 = "2x2xi32=[42 43][44 45]";
- absl::string_view buf_string2 = "2x3xf64=[1 2 3][4 5 6]";
+ std::string buf_string1 = "2x2xi32=[42 43][44 45]";
+ std::string buf_string2 = "2x3xf64=[1 2 3][4 5 6]";
vm::ref<iree_vm_list_t> variant_list;
- IREE_ASSERT_OK(ParseToVariantList(allocator_, {buf_string1, buf_string2},
- &variant_list));
+ IREE_ASSERT_OK(ParseToVariantList(
+ allocator_, std::vector<std::string>{buf_string1, buf_string2},
+ &variant_list));
std::stringstream os;
IREE_ASSERT_OK(PrintVariantList(variant_list.get(), &os));
- EXPECT_EQ(os.str(),
- absl::StrCat("result[0]: hal.buffer_view\n", buf_string1,
- "\nresult[1]: hal.buffer_view\n", buf_string2, "\n"));
+ EXPECT_EQ(os.str(), std::string("result[0]: hal.buffer_view\n") +
+ buf_string1 + "\nresult[1]: hal.buffer_view\n" +
+ buf_string2 + "\n");
}
} // namespace
diff --git a/iree/vm/BUILD b/iree/vm/BUILD
index 6bde6f7..04b5a62 100644
--- a/iree/vm/BUILD
+++ b/iree/vm/BUILD
@@ -33,8 +33,8 @@
cc_library(
name = "cc",
hdrs = [
- "module_abi_packing.h",
"native_module_cc.h",
+ "native_module_packing.h",
"ref_cc.h",
],
deps = [
@@ -42,9 +42,7 @@
"//iree/base",
"//iree/base:core_headers",
"//iree/base:status",
- "@com_google_absl//absl/strings",
- "@com_google_absl//absl/types:optional",
- "@com_google_absl//absl/types:span",
+ "//iree/base/internal:span",
],
)
@@ -248,8 +246,6 @@
"//iree/testing:gtest",
"//iree/testing:gtest_main",
"//iree/vm/test:all_bytecode_modules_c",
- "@com_google_absl//absl/strings",
- "@com_google_absl//absl/types:span",
],
)
diff --git a/iree/vm/CMakeLists.txt b/iree/vm/CMakeLists.txt
index 8579f5f..e771e6e 100644
--- a/iree/vm/CMakeLists.txt
+++ b/iree/vm/CMakeLists.txt
@@ -25,16 +25,14 @@
NAME
cc
HDRS
- "module_abi_packing.h"
"native_module_cc.h"
+ "native_module_packing.h"
"ref_cc.h"
DEPS
::vm
- absl::optional
- absl::span
- absl::strings
iree::base
iree::base::core_headers
+ iree::base::internal::span
iree::base::status
PUBLIC
)
@@ -201,8 +199,6 @@
DEPS
::bytecode_module
::vm
- absl::span
- absl::strings
iree::base::logging
iree::base::status
iree::testing::gtest
diff --git a/iree/vm/bytecode_dispatch_test.cc b/iree/vm/bytecode_dispatch_test.cc
index 2a48ccf..2570e71 100644
--- a/iree/vm/bytecode_dispatch_test.cc
+++ b/iree/vm/bytecode_dispatch_test.cc
@@ -10,8 +10,6 @@
// avoid defining the IR inline here so that we can run this test on platforms
// that we can't run the full MLIR compiler stack on.
-#include "absl/strings/match.h"
-#include "absl/strings/str_replace.h"
#include "iree/base/logging.h"
#include "iree/base/status.h"
#include "iree/testing/gtest.h"
@@ -29,9 +27,11 @@
};
std::ostream& operator<<(std::ostream& os, const TestParams& params) {
- return os << absl::StrReplaceAll(params.module_file.name,
- {{":", "_"}, {".", "_"}})
- << "_" << params.function_name;
+ std::string name{params.module_file.name};
+ auto name_sv = iree_make_string_view(name.data(), name.size());
+ iree_string_view_replace_char(name_sv, ':', '_');
+ iree_string_view_replace_char(name_sv, '.', '_');
+ return os << name << "_" << params.function_name;
}
std::vector<TestParams> GetModuleTestParams() {
@@ -109,7 +109,7 @@
TEST_P(VMBytecodeDispatchTest, Check) {
const auto& test_params = GetParam();
- bool expect_failure = absl::StartsWith(test_params.function_name, "fail_");
+ bool expect_failure = test_params.function_name.find("fail_") == 0;
iree_status_t status = RunFunction(test_params.function_name.c_str());
if (iree_status_is_ok(status)) {
diff --git a/iree/vm/native_module_cc.h b/iree/vm/native_module_cc.h
index 9cef962..e08177f 100644
--- a/iree/vm/native_module_cc.h
+++ b/iree/vm/native_module_cc.h
@@ -10,12 +10,11 @@
#include <cstring>
#include <memory>
-#include "absl/strings/str_cat.h"
-#include "absl/types/span.h"
#include "iree/base/api.h"
+#include "iree/base/internal/span.h"
#include "iree/base/status.h"
#include "iree/vm/module.h"
-#include "iree/vm/module_abi_packing.h" // IWYU pragma: export
+#include "iree/vm/native_module_packing.h" // IWYU pragma: export
#include "iree/vm/stack.h"
#ifndef __cplusplus
@@ -33,7 +32,7 @@
// Functions are defined on the State type as member functions returning either
// Status or StatusOr. Arguments are passed as primitive types (int32_t),
// wrapped ref objects (vm::ref<my_type_t>&), or some nesting of std::array,
-// std::tuple, and absl::Span to match fixed-length arrays of the same type,
+// std::tuple, and std::span to match fixed-length arrays of the same type,
// tuples of mixed types, or dynamic arrays (variadic arguments). Results may be
// returned as either their type or an std::tuple/std::array of types.
//
@@ -62,13 +61,13 @@
// // Ownership transfers to the caller.
// iree_vm_module_t* create_my_module(iree_allocator_t allocator) {
// return std::make_unique<MyModule>("my_module", allocator,
-// absl::MakeConstSpan(kCustomModuleFunctions)).release()->interface();
+// std::span{kCustomModuleFunctions}).release()->interface();
// }
template <typename State>
class NativeModule {
public:
NativeModule(const char* name, iree_allocator_t allocator,
- absl::Span<const NativeFunction<State>> dispatch_table)
+ iree::span<const NativeFunction<State>> dispatch_table)
: name_(name), allocator_(allocator), dispatch_table_(dispatch_table) {
IREE_CHECK_OK(iree_vm_module_initialize(&interface_, this));
interface_.destroy = NativeModule::ModuleDestroy;
@@ -242,7 +241,7 @@
const iree_allocator_t allocator_;
iree_vm_module_t interface_;
- const absl::Span<const NativeFunction<State>> dispatch_table_;
+ const iree::span<const NativeFunction<State>> dispatch_table_;
};
} // namespace vm
diff --git a/iree/vm/module_abi_packing.h b/iree/vm/native_module_packing.h
similarity index 88%
rename from iree/vm/module_abi_packing.h
rename to iree/vm/native_module_packing.h
index 52283b1..e921b7c 100644
--- a/iree/vm/module_abi_packing.h
+++ b/iree/vm/native_module_packing.h
@@ -12,9 +12,8 @@
#include <utility>
#include <vector>
-#include "absl/types/optional.h"
-#include "absl/types/span.h"
#include "iree/base/api.h"
+#include "iree/base/internal/span.h"
#include "iree/base/status.h"
#include "iree/vm/builtin_types.h"
#include "iree/vm/module.h"
@@ -22,6 +21,15 @@
#include "iree/vm/ref_cc.h"
#include "iree/vm/stack.h"
+// std::string_view is available starting in C++17.
+// Prior to that only IREE's C iree_string_view_t is available.
+#if defined(__has_include)
+#if __has_include(<string_view>) && __cplusplus >= 201703L
+#define IREE_HAVE_STD_STRING_VIEW 1
+#include <string_view>
+#endif // __has_include(<string_view>)
+#endif // __has_include
+
namespace iree {
namespace vm {
namespace packing {
@@ -192,9 +200,15 @@
static constexpr const auto conv_chars = literal("r");
};
template <>
-struct cconv_map<absl::string_view> {
+struct cconv_map<iree_string_view_t> {
static constexpr const auto conv_chars = literal("r");
};
+#if defined(IREE_HAVE_STD_STRING_VIEW)
+template <>
+struct cconv_map<std::string_view> {
+ static constexpr const auto conv_chars = literal("r");
+};
+#endif // IREE_HAVE_STD_STRING_VIEW
template <typename U, size_t S>
struct cconv_map<std::array<U, S>> {
@@ -209,7 +223,7 @@
};
template <typename U>
-struct cconv_map<absl::Span<U>> {
+struct cconv_map<iree::span<U>> {
static constexpr const auto conv_chars = concat_literals(
literal("C"), cconv_map<typename impl::remove_cvref<U>::type>::conv_chars,
literal("D"));
@@ -292,15 +306,19 @@
template <typename T>
struct ParamUnpack<const ref<T>>;
template <>
-struct ParamUnpack<absl::string_view>;
+struct ParamUnpack<iree_string_view_t>;
+#if defined(IREE_HAVE_STD_STRING_VIEW)
+template <>
+struct ParamUnpack<std::string_view>;
+#endif // IREE_HAVE_STD_STRING_VIEW
template <typename U, size_t S>
struct ParamUnpack<std::array<U, S>>;
template <typename... Ts>
struct ParamUnpack<std::tuple<Ts...>>;
template <typename U>
-struct ParamUnpack<absl::Span<U>, enable_if_not_primitive<U>>;
+struct ParamUnpack<iree::span<U>, enable_if_not_primitive<U>>;
template <typename U>
-struct ParamUnpack<absl::Span<U>, enable_if_primitive<U>>;
+struct ParamUnpack<iree::span<U>, enable_if_primitive<U>>;
struct Unpacker {
template <typename... Ts>
@@ -413,14 +431,40 @@
// An `iree.byte_buffer` containing a string.
// The string view is aliased directly into the underlying byte buffer.
template <>
-struct ParamUnpack<absl::string_view> {
- using storage_type = absl::string_view;
+struct ParamUnpack<iree_string_view_t> {
+ using storage_type = iree_string_view_t;
static void Load(Status& status, params_ptr_t& ptr, storage_type& out_param) {
auto* reg_ptr = reinterpret_cast<iree_vm_ref_t*>(ptr);
ptr += sizeof(iree_vm_ref_t);
if (reg_ptr->type == ref_type_descriptor<iree_vm_buffer_t>::get()->type) {
auto byte_span = reinterpret_cast<iree_vm_buffer_t*>(reg_ptr->ptr)->data;
- out_param = absl::string_view{
+ out_param = iree_make_string_view(
+ reinterpret_cast<const char*>(byte_span.data), byte_span.data_length);
+ } else if (IREE_UNLIKELY(reg_ptr->type != IREE_VM_REF_TYPE_NULL)) {
+ status = iree_make_status(
+ IREE_STATUS_INVALID_ARGUMENT,
+ "parameter contains a reference to the wrong type; "
+ "have %.*s but expected %.*s",
+ (int)iree_vm_ref_type_name(reg_ptr->type).size,
+ iree_vm_ref_type_name(reg_ptr->type).data,
+ (int)ref_type_descriptor<iree_vm_buffer_t>::get()->type_name.size,
+ ref_type_descriptor<iree_vm_buffer_t>::get()->type_name.data);
+ } else {
+ // NOTE: empty string is allowed here!
+ out_param = iree_string_view_empty();
+ }
+ }
+};
+#if defined(IREE_HAVE_STD_STRING_VIEW)
+template <>
+struct ParamUnpack<std::string_view> {
+ using storage_type = std::string_view;
+ static void Load(Status& status, params_ptr_t& ptr, storage_type& out_param) {
+ auto* reg_ptr = reinterpret_cast<iree_vm_ref_t*>(ptr);
+ ptr += sizeof(iree_vm_ref_t);
+ if (reg_ptr->type == ref_type_descriptor<iree_vm_buffer_t>::get()->type) {
+ auto byte_span = reinterpret_cast<iree_vm_buffer_t*>(reg_ptr->ptr)->data;
+ out_param = std::string_view{
reinterpret_cast<const char*>(byte_span.data), byte_span.data_length};
} else if (IREE_UNLIKELY(reg_ptr->type != IREE_VM_REF_TYPE_NULL)) {
status = iree_make_status(
@@ -437,6 +481,7 @@
}
}
};
+#endif // IREE_HAVE_STD_STRING_VIEW
// Arrays are C++ ABI only representing a fixed repeated field (`i32, i32`).
template <typename U, size_t S>
@@ -473,7 +518,7 @@
// In the future we could check that all subelements are primitives and alias if
// the host machine endianness is the same.
template <typename U>
-struct ParamUnpack<absl::Span<U>, enable_if_not_primitive<U>> {
+struct ParamUnpack<iree::span<U>, enable_if_not_primitive<U>> {
using element_type = typename impl::remove_cvref<U>::type;
using storage_type = std::vector<element_type>;
static void Load(Status& status, params_ptr_t& ptr, storage_type& out_param) {
@@ -489,14 +534,14 @@
// Simple primitive variadic span (like `i32...`). We can alias directly into
// the argument buffer so long as endianness matches.
template <typename U>
-struct ParamUnpack<absl::Span<U>, enable_if_primitive<U>> {
+struct ParamUnpack<iree::span<U>, enable_if_primitive<U>> {
using element_type = U;
- using storage_type = absl::Span<const element_type>;
+ using storage_type = iree::span<const element_type>;
static void Load(Status& status, params_ptr_t& ptr, storage_type& out_param) {
iree_host_size_t count = *reinterpret_cast<const int32_t*>(ptr);
ptr += sizeof(int32_t);
out_param =
- absl::MakeConstSpan(reinterpret_cast<const element_type*>(ptr), count);
+ iree::span<U>(reinterpret_cast<const element_type*>(ptr), count);
ptr += sizeof(element_type) * count;
}
};
@@ -638,22 +683,20 @@
template <typename Owner, typename Result, typename... Params>
constexpr NativeFunction<Owner> MakeNativeFunction(
- absl::string_view name, StatusOr<Result> (Owner::*fn)(Params...)) {
+ const char* name, StatusOr<Result> (Owner::*fn)(Params...)) {
using dispatch_functor_t = packing::DispatchFunctor<Owner, Result, Params...>;
- return {{name.data(), name.size()},
+ return {iree_make_cstring_view(name),
packing::cconv_storage<Result, sizeof...(Params), Params...>::value(),
- (void (Owner::*)())fn,
- &dispatch_functor_t::Call};
+ (void (Owner::*)())fn, &dispatch_functor_t::Call};
}
template <typename Owner, typename... Params>
constexpr NativeFunction<Owner> MakeNativeFunction(
- absl::string_view name, Status (Owner::*fn)(Params...)) {
+ const char* name, Status (Owner::*fn)(Params...)) {
using dispatch_functor_t = packing::DispatchFunctorVoid<Owner, Params...>;
- return {{name.data(), name.size()},
+ return {iree_make_cstring_view(name),
packing::cconv_storage_void<sizeof...(Params), Params...>::value(),
- (void (Owner::*)())fn,
- &dispatch_functor_t::Call};
+ (void (Owner::*)())fn, &dispatch_functor_t::Call};
}
} // namespace vm
diff --git a/iree/vm/test/emitc/CMakeLists.txt b/iree/vm/test/emitc/CMakeLists.txt
index a58ffbc..8ba0bd5 100644
--- a/iree/vm/test/emitc/CMakeLists.txt
+++ b/iree/vm/test/emitc/CMakeLists.txt
@@ -14,7 +14,6 @@
SRCS
"module_test.cc"
DEPS
- absl::strings
iree::base::logging
iree::base::status
iree::testing::gtest
diff --git a/iree/vm/test/emitc/module_test.cc b/iree/vm/test/emitc/module_test.cc
index f621a56..163150d 100644
--- a/iree/vm/test/emitc/module_test.cc
+++ b/iree/vm/test/emitc/module_test.cc
@@ -4,8 +4,6 @@
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#include "absl/strings/match.h"
-#include "absl/strings/str_replace.h"
#include "iree/base/logging.h"
#include "iree/base/status.h"
#include "iree/testing/gtest.h"
@@ -47,7 +45,11 @@
std::ostream& operator<<(std::ostream& os, const TestParams& params) {
std::string qualified_name = params.module_name + "." + params.local_name;
- return os << absl::StrReplaceAll(qualified_name, {{":", "_"}, {".", "_"}});
+ auto name_sv =
+ iree_make_string_view(qualified_name.data(), qualified_name.size());
+ iree_string_view_replace_char(name_sv, ':', '_');
+ iree_string_view_replace_char(name_sv, '.', '_');
+ return os << qualified_name;
}
std::vector<TestParams> GetModuleTestParams() {
@@ -137,7 +139,7 @@
TEST_P(VMCModuleTest, Check) {
const auto& test_params = GetParam();
- bool expect_failure = absl::StartsWith(test_params.local_name, "fail_");
+ bool expect_failure = test_params.local_name.find("fail_") == 0;
iree::Status result =
RunFunction(test_params.module_name, test_params.local_name);
