hal/buffer_view_string_util.cc - 3p/openxla/iree - Git at Google

 // Copyright 2019 Google LLC
 //
 // 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
 //
 //      https://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.

 #include "third_party/mlir_edge/iree/hal/buffer_view_string_util.h"

 #include <functional>
 #include <sstream>
 #include <type_traits>

 #include "third_party/absl/strings/ascii.h"
 #include "third_party/absl/strings/escaping.h"
 #include "third_party/absl/strings/numbers.h"
 #include "third_party/absl/strings/str_join.h"
 #include "third_party/absl/strings/str_split.h"
 #include "third_party/absl/strings/strip.h"
 #include "third_party/absl/types/optional.h"
 #include "third_party/absl/types/source_location.h"
 #include "third_party/mlir_edge/iree/base/status.h"
 #include "third_party/mlir_edge/iree/hal/heap_buffer.h"

 namespace iree {
 namespace hal {

 namespace {

 // Returns true if the given type is represented as binary hex data.
 bool IsBinaryType(absl::string_view type_str) {
   return !type_str.empty() && absl::ascii_isdigit(type_str[0]);
 }

 // Parses binary hex data.
 Status ParseBinaryData(absl::string_view data_str, Buffer* buffer) {
   data_str = absl::StripAsciiWhitespace(data_str);
   ASSIGN_OR_RETURN(auto mapping,
                    buffer->MapMemory<uint8_t>(MemoryAccess::kDiscardWrite));
   auto contents = mapping.mutable_contents();
   size_t dst_i = 0;
   size_t src_i = 0;
   while (src_i < data_str.size() && dst_i < contents.size()) {
     char c = data_str[src_i];
     if (absl::ascii_isspace(c) || c == ',') {
       ++src_i;
       continue;
     }
     if (src_i + 1 >= data_str.size()) {
       return InvalidArgumentErrorBuilder(ABSL_LOC)
              << "Invalid input hex data (offset=" << src_i << ")";
     }
     strings::a2b_hex(data_str.data() + src_i, contents.data() + dst_i, 1);
     src_i += 2;
     ++dst_i;
   }
   if (dst_i < contents.size()) {
     return InvalidArgumentErrorBuilder(ABSL_LOC)
            << "Too few elements to fill type; expected " << contents.size()
            << " but only read " << dst_i;
   } else if (data_str.size() - src_i > 0) {
     return InvalidArgumentErrorBuilder(ABSL_LOC)
            << "Input data string contains more elements than the underlying "
               "buffer ("
            << contents.size() << ")";
   }
   return OkStatus();
 }

 // Prints binary hex data.
 Status PrintBinaryData(int element_size, Buffer* buffer, size_t max_entries,
                        std::ostream* stream) {
   max_entries *= element_size;  // Counting bytes, but treat them as elements.
   ASSIGN_OR_RETURN(auto mapping,
                    buffer->MapMemory<uint8_t>(MemoryAccess::kRead));
   auto contents = mapping.contents();
   char hex_buffer[8 * 2];
   for (size_t i = 0; i < std::min(max_entries, mapping.size());
        i += element_size) {
     if (i > 0) *stream << " ";
     strings::b2a_hex(contents.data() + i, hex_buffer, element_size);
     *stream << hex_buffer;
   }
   if (mapping.size() > max_entries) *stream << "...";
   return OkStatus();
 }

 template <typename ElementType, typename Enabled = void>
 struct SimpleStrToValue {
   absl::optional<ElementType> operator()(absl::string_view text) const = delete;
 };

 template <typename IntegerType>
 struct SimpleStrToValue<
     IntegerType,
     typename std::enable_if<(sizeof(IntegerType) < 4), void>::type> {
   absl::optional<IntegerType> operator()(absl::string_view text) const {
     int32_t value;
     return absl::SimpleAtoi(text, &value) ? absl::optional<IntegerType>{value}
                                           : absl::nullopt;
   }
 };

 template <typename IntegerType>
 struct SimpleStrToValue<
     IntegerType,
     typename std::enable_if<(sizeof(IntegerType) >= 4), void>::type> {
   absl::optional<IntegerType> operator()(absl::string_view text) const {
     IntegerType value;
     return absl::SimpleAtoi(text, &value) ? absl::optional<IntegerType>{value}
                                           : absl::nullopt;
   }
 };

 template <>
 struct SimpleStrToValue<float, void> {
   absl::optional<float> operator()(absl::string_view text) const {
     float value;
     return absl::SimpleAtof(text, &value) ? absl::optional<float>{value}
                                           : absl::nullopt;
   }
 };

 template <>
 struct SimpleStrToValue<double, void> {
   absl::optional<double> operator()(absl::string_view text) const {
     double value;
     return absl::SimpleAtod(text, &value) ? absl::optional<double>{value}
                                           : absl::nullopt;
   }
 };

 template <typename T>
 Status ParseNumericalDataElement(absl::string_view data_str, size_t token_start,
                                  size_t token_end, absl::Span<T> contents,
                                  int dst_i) {
   if (dst_i >= contents.size()) {
     return InvalidArgumentErrorBuilder(ABSL_LOC)
            << "Input data string contains more elements than the underlying "
               "buffer ("
            << contents.size() << ")";
   }
   auto element_str = data_str.substr(token_start, token_end - token_start + 1);
   auto element = SimpleStrToValue<T>()(element_str);
   if (!element.has_value()) {
     return InvalidArgumentErrorBuilder(ABSL_LOC)
            << "Unable to parse element " << dst_i << " = '" << element_str
            << "'";
   }
   contents[dst_i] = element.value();
   return OkStatus();
 }

 template <typename T>
 Status ParseNumericalDataAsType(absl::string_view data_str, Buffer* buffer) {
   ASSIGN_OR_RETURN(auto mapping,
                    buffer->MapMemory<T>(MemoryAccess::kDiscardWrite));
   auto contents = mapping.mutable_contents();
   size_t src_i = 0;
   size_t dst_i = 0;
   size_t token_start = std::string::npos;
   while (src_i < data_str.size()) {
     char c = data_str[src_i++];
     bool is_separator =
         absl::ascii_isspace(c) || c == ',' || c == '[' || c == ']';
     if (token_start == std::string::npos) {
       if (!is_separator) {
         token_start = src_i - 1;
       }
       continue;
     } else if (token_start != std::string::npos && !is_separator) {
       continue;
     }
     RETURN_IF_ERROR(ParseNumericalDataElement<T>(data_str, token_start,
                                                  src_i - 2, contents, dst_i++));
     token_start = std::string::npos;
   }
   if (token_start != std::string::npos) {
     RETURN_IF_ERROR(ParseNumericalDataElement<T>(
         data_str, token_start, data_str.size() - 1, contents, dst_i++));
   }
   if (dst_i < contents.size()) {
     return InvalidArgumentErrorBuilder(ABSL_LOC)
            << "Input data string contains fewer elements than the underlying "
               "buffer (expected "
            << contents.size() << ")";
   }
   return OkStatus();
 }

 // Parses numerical data (ints, floats, etc) in some typed form.
 Status ParseNumericalData(absl::string_view type_str,
                           absl::string_view data_str, Buffer* buffer) {
   if (type_str == "i8") {
     return ParseNumericalDataAsType<int8_t>(data_str, buffer);
   } else if (type_str == "u8") {
     return ParseNumericalDataAsType<uint8_t>(data_str, buffer);
   } else if (type_str == "i16") {
     return ParseNumericalDataAsType<int16_t>(data_str, buffer);
   } else if (type_str == "u16") {
     return ParseNumericalDataAsType<uint16_t>(data_str, buffer);
   } else if (type_str == "i32") {
     return ParseNumericalDataAsType<int32_t>(data_str, buffer);
   } else if (type_str == "u32") {
     return ParseNumericalDataAsType<uint32_t>(data_str, buffer);
   } else if (type_str == "i64") {
     return ParseNumericalDataAsType<int64_t>(data_str, buffer);
   } else if (type_str == "u64") {
     return ParseNumericalDataAsType<uint64_t>(data_str, buffer);
   } else if (type_str == "f32") {
     return ParseNumericalDataAsType<float>(data_str, buffer);
   } else if (type_str == "f64") {
     return ParseNumericalDataAsType<double>(data_str, buffer);
   } else {
     return InvalidArgumentErrorBuilder(ABSL_LOC)
            << "Unsupported type: " << type_str;
   }
 }

 template <typename T>
 void PrintElementList(const Shape& shape, absl::Span<const T> data,
                       size_t* max_entries, std::ostream* stream) {
   if (shape.empty()) {
     // Scalar value.
     PrintElementList({1}, data, max_entries, stream);
     return;
   } else if (shape.size() == 1) {
     // Leaf dimension; output data.
     size_t max_count = std::min(*max_entries, static_cast<size_t>(shape[0]));
     *stream << absl::StrJoin(data.subspan(0, max_count), " ");
     if (max_count < shape[0]) {
       *stream << "...";
     }
     *max_entries -= max_count;
   } else {
     // Nested; recurse into next dimension.
     Shape nested_shape = Shape(shape.subspan(1));
     size_t length = nested_shape.element_count();
     size_t offset = 0;
     for (int i = 0; i < shape[0]; ++i) {
       *stream << "[";
       PrintElementList<T>(nested_shape, data.subspan(offset, length),
                           max_entries, stream);
       offset += length;
       *stream << "]";
     }
   }
 }

 template <typename T>
 Status PrintNumericalDataAsType(const Shape& shape, Buffer* buffer,
                                 size_t max_entries, std::ostream* stream) {
   ASSIGN_OR_RETURN(auto mapping, buffer->MapMemory<T>(MemoryAccess::kRead));
   PrintElementList(shape, mapping.contents(), &max_entries, stream);
   return OkStatus();
 }

 // Prints numerical data (ints, floats, etc) from some typed form.
 Status PrintNumericalData(const Shape& shape, absl::string_view type_str,
                           Buffer* buffer, size_t max_entries,
                           std::ostream* stream) {
   if (type_str == "i8") {
     return PrintNumericalDataAsType<int8_t>(shape, buffer, max_entries, stream);
   } else if (type_str == "u8") {
     return PrintNumericalDataAsType<uint8_t>(shape, buffer, max_entries,
                                              stream);
   } else if (type_str == "i16") {
     return PrintNumericalDataAsType<int16_t>(shape, buffer, max_entries,
                                              stream);
   } else if (type_str == "u16") {
     return PrintNumericalDataAsType<uint16_t>(shape, buffer, max_entries,
                                               stream);
   } else if (type_str == "i32") {
     return PrintNumericalDataAsType<int32_t>(shape, buffer, max_entries,
                                              stream);
   } else if (type_str == "u32") {
     return PrintNumericalDataAsType<uint32_t>(shape, buffer, max_entries,
                                               stream);
   } else if (type_str == "i64") {
     return PrintNumericalDataAsType<int64_t>(shape, buffer, max_entries,
                                              stream);
   } else if (type_str == "u64") {
     return PrintNumericalDataAsType<uint64_t>(shape, buffer, max_entries,
                                               stream);
   } else if (type_str == "f32") {
     return PrintNumericalDataAsType<float>(shape, buffer, max_entries, stream);
   } else if (type_str == "f64") {
     return PrintNumericalDataAsType<double>(shape, buffer, max_entries, stream);
   } else {
     return InvalidArgumentErrorBuilder(ABSL_LOC)
            << "Unsupported type: " << type_str;
   }
 }

 }  // namespace

 StatusOr<int> GetTypeElementSize(absl::string_view type_str) {
   if (type_str.empty()) {
     return InvalidArgumentErrorBuilder(ABSL_LOC) << "Type is empty";
   } else if (IsBinaryType(type_str)) {
     // If the first character is a digit then we are dealign with binary data.
     // The type is just the number of bytes per element.
     int element_size = 0;
     if (!absl::SimpleAtoi(type_str, &element_size)) {
       return InvalidArgumentErrorBuilder(ABSL_LOC)
              << "Unable to parse element size type '" << type_str << "'";
     }
     return element_size;
   }
   // We know that our types are single characters followed by bit counts.
   // If we start to support other types we may need to do something more clever.
   int bit_count = 0;
   if (!absl::SimpleAtoi(type_str.substr(1), &bit_count)) {
     return InvalidArgumentErrorBuilder(ABSL_LOC)
            << "Unable to parse type bit count from '" << type_str
            << "'; expecting something like 'i32'";
   }
   return bit_count / 8;
 }

 StatusOr<Shape> ParseShape(absl::string_view shape_str) {
   std::vector<int> dims;
   for (auto dim_str : absl::StrSplit(shape_str, 'x', absl::SkipWhitespace())) {
     int dim_value = 0;
     if (!absl::SimpleAtoi(dim_str, &dim_value)) {
       return InvalidArgumentErrorBuilder(ABSL_LOC)
              << "Invalid shape dimension '" << dim_str
              << "' while parsing shape '" << shape_str << "'";
     }
     dims.push_back(dim_value);
   }
   return Shape{dims};
 }

 StatusOr<BufferView> ParseBufferViewFromString(
     absl::string_view buffer_view_str, hal::Allocator* allocator) {
   // Strip whitespace that may come along (linefeeds/etc).
   buffer_view_str = absl::StripAsciiWhitespace(buffer_view_str);
   if (buffer_view_str.empty()) {
     // Empty lines denote empty buffer_views.
     return BufferView{};
   }

   // Split into the components we can work with: shape, type, and data.
   absl::string_view shape_and_type_str;
   absl::string_view data_str;
   auto equal_index = buffer_view_str.find('=');
   if (equal_index == std::string::npos) {
     // Treat a lack of = as defaulting the data to zeros.
     shape_and_type_str = buffer_view_str;
   } else {
     shape_and_type_str = buffer_view_str.substr(0, equal_index);
     data_str = buffer_view_str.substr(equal_index + 1);
   }
   absl::string_view shape_str;
   absl::string_view type_str;
   auto last_x_index = shape_and_type_str.rfind('x');
   if (last_x_index == std::string::npos) {
     // Scalar.
     type_str = shape_and_type_str;
   } else {
     // Has a shape.
     shape_str = shape_and_type_str.substr(0, last_x_index);
     type_str = shape_and_type_str.substr(last_x_index + 1);
   }

   // Populate BufferView metadata required for allocation.
   BufferView result;
   ASSIGN_OR_RETURN(result.element_size, GetTypeElementSize(type_str));
   ASSIGN_OR_RETURN(result.shape, ParseShape(shape_str));

   // Allocate the host buffer.
   size_t allocation_size = result.shape.element_count() * result.element_size;
   if (allocator) {
     ASSIGN_OR_RETURN(
         result.buffer,
         allocator->Allocate(MemoryType::kHostLocal | MemoryType::kDeviceVisible,
                             BufferUsage::kAll | BufferUsage::kConstant,
                             allocation_size));
   } else {
     result.buffer = HeapBuffer::Allocate(
         MemoryType::kHostLocal, BufferUsage::kAll | BufferUsage::kConstant,
         allocation_size);
   }

   if (!data_str.empty()) {
     // Parse the data from the string right into the buffer.
     if (IsBinaryType(type_str)) {
       // Parse as binary hex.
       RETURN_IF_ERROR(ParseBinaryData(data_str, result.buffer.get()));
     } else {
       // Parse as some nicely formatted type.
       RETURN_IF_ERROR(
           ParseNumericalData(type_str, data_str, result.buffer.get()));
     }
   }

   return result;
 }

 StatusOr<BufferViewPrintMode> ParseBufferViewPrintMode(absl::string_view str) {
   char str_char = str.empty() ? '?' : str[0];
   switch (str_char) {
     case 'b':
       return BufferViewPrintMode::kBinary;
     case 'i':
       return BufferViewPrintMode::kSignedInteger;
     case 'u':
       return BufferViewPrintMode::kUnsignedInteger;
     case 'f':
       return BufferViewPrintMode::kFloatingPoint;
     default:
       return InvalidArgumentErrorBuilder(ABSL_LOC)
              << "Unsupported output type '" << str << "'";
   }
 }

 StatusOr<std::string> PrintBufferViewToString(const BufferView& buffer_view,
                                               BufferViewPrintMode print_mode,
                                               size_t max_entries) {
   std::string result;
   RETURN_IF_ERROR(
       PrintBufferViewToString(buffer_view, print_mode, max_entries, &result));
   return result;
 }

 Status PrintBufferViewToString(const BufferView& buffer_view,
                                BufferViewPrintMode print_mode,
                                size_t max_entries, std::string* out_result) {
   std::ostringstream stream;
   RETURN_IF_ERROR(
       PrintBufferViewToStream(buffer_view, print_mode, max_entries, &stream));
   *out_result = stream.str();
   return OkStatus();
 }

 Status PrintBufferViewToStream(const BufferView& buffer_view,
                                BufferViewPrintMode print_mode,
                                size_t max_entries, std::ostream* stream) {
   if (!buffer_view.buffer) {
     // No buffer means the buffer_view is empty. We use the empty string to
     // denote this (as we have no useful information).
     return OkStatus();
   }

   // Pick a type based on the element size and the printing mode.
   std::string type_str;
   switch (print_mode) {
     case BufferViewPrintMode::kBinary:
       type_str = std::to_string(buffer_view.element_size);
       break;
     case BufferViewPrintMode::kSignedInteger:
       absl::StrAppend(&type_str, "i", buffer_view.element_size * 8);
       break;
     case BufferViewPrintMode::kUnsignedInteger:
       absl::StrAppend(&type_str, "u", buffer_view.element_size * 8);
       break;
     case BufferViewPrintMode::kFloatingPoint:
       absl::StrAppend(&type_str, "f", buffer_view.element_size * 8);
       break;
   }

   // [shape]x[type]= prefix (taking into account scalar values).
   *stream << absl::StrJoin(buffer_view.shape.begin(), buffer_view.shape.end(),
                            "x");
   if (!buffer_view.shape.empty()) *stream << "x";
   *stream << type_str;
   *stream << "=";

   if (IsBinaryType(type_str)) {
     return PrintBinaryData(buffer_view.element_size, buffer_view.buffer.get(),
                            max_entries, stream);
   } else {
     return PrintNumericalData(buffer_view.shape, type_str,
                               buffer_view.buffer.get(), max_entries, stream);
   }
 }

 }  // namespace hal
 }  // namespace iree
	// Copyright 2019 Google LLC
	//
	// 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
	//
	// https://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.

	#include "third_party/mlir_edge/iree/hal/buffer_view_string_util.h"

	#include <functional>
	#include <sstream>
	#include <type_traits>

	#include "third_party/absl/strings/ascii.h"
	#include "third_party/absl/strings/escaping.h"
	#include "third_party/absl/strings/numbers.h"
	#include "third_party/absl/strings/str_join.h"
	#include "third_party/absl/strings/str_split.h"
	#include "third_party/absl/strings/strip.h"
	#include "third_party/absl/types/optional.h"
	#include "third_party/absl/types/source_location.h"
	#include "third_party/mlir_edge/iree/base/status.h"
	#include "third_party/mlir_edge/iree/hal/heap_buffer.h"

	namespace iree {
	namespace hal {

	namespace {

	// Returns true if the given type is represented as binary hex data.
	bool IsBinaryType(absl::string_view type_str) {
	return !type_str.empty() && absl::ascii_isdigit(type_str[0]);
	}

	// Parses binary hex data.
	Status ParseBinaryData(absl::string_view data_str, Buffer* buffer) {
	data_str = absl::StripAsciiWhitespace(data_str);
	ASSIGN_OR_RETURN(auto mapping,
	buffer->MapMemory<uint8_t>(MemoryAccess::kDiscardWrite));
	auto contents = mapping.mutable_contents();
	size_t dst_i = 0;
	size_t src_i = 0;
	while (src_i < data_str.size() && dst_i < contents.size()) {
	char c = data_str[src_i];
	if (absl::ascii_isspace(c) \|\| c == ',') {
	++src_i;
	continue;
	}
	if (src_i + 1 >= data_str.size()) {
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Invalid input hex data (offset=" << src_i << ")";
	}
	strings::a2b_hex(data_str.data() + src_i, contents.data() + dst_i, 1);
	src_i += 2;
	++dst_i;
	}
	if (dst_i < contents.size()) {
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Too few elements to fill type; expected " << contents.size()
	<< " but only read " << dst_i;
	} else if (data_str.size() - src_i > 0) {
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Input data string contains more elements than the underlying "
	"buffer ("
	<< contents.size() << ")";
	}
	return OkStatus();
	}

	// Prints binary hex data.
	Status PrintBinaryData(int element_size, Buffer* buffer, size_t max_entries,
	std::ostream* stream) {
	max_entries *= element_size; // Counting bytes, but treat them as elements.
	ASSIGN_OR_RETURN(auto mapping,
	buffer->MapMemory<uint8_t>(MemoryAccess::kRead));
	auto contents = mapping.contents();
	char hex_buffer[8 * 2];
	for (size_t i = 0; i < std::min(max_entries, mapping.size());
	i += element_size) {
	if (i > 0) *stream << " ";
	strings::b2a_hex(contents.data() + i, hex_buffer, element_size);
	*stream << hex_buffer;
	}
	if (mapping.size() > max_entries) *stream << "...";
	return OkStatus();
	}

	template <typename ElementType, typename Enabled = void>
	struct SimpleStrToValue {
	absl::optional<ElementType> operator()(absl::string_view text) const = delete;
	};

	template <typename IntegerType>
	struct SimpleStrToValue<
	IntegerType,
	typename std::enable_if<(sizeof(IntegerType) < 4), void>::type> {
	absl::optional<IntegerType> operator()(absl::string_view text) const {
	int32_t value;
	return absl::SimpleAtoi(text, &value) ? absl::optional<IntegerType>{value}
	: absl::nullopt;
	}
	};

	template <typename IntegerType>
	struct SimpleStrToValue<
	IntegerType,
	typename std::enable_if<(sizeof(IntegerType) >= 4), void>::type> {
	absl::optional<IntegerType> operator()(absl::string_view text) const {
	IntegerType value;
	return absl::SimpleAtoi(text, &value) ? absl::optional<IntegerType>{value}
	: absl::nullopt;
	}
	};

	template <>
	struct SimpleStrToValue<float, void> {
	absl::optional<float> operator()(absl::string_view text) const {
	float value;
	return absl::SimpleAtof(text, &value) ? absl::optional<float>{value}
	: absl::nullopt;
	}
	};

	template <>
	struct SimpleStrToValue<double, void> {
	absl::optional<double> operator()(absl::string_view text) const {
	double value;
	return absl::SimpleAtod(text, &value) ? absl::optional<double>{value}
	: absl::nullopt;
	}
	};

	template <typename T>
	Status ParseNumericalDataElement(absl::string_view data_str, size_t token_start,
	size_t token_end, absl::Span<T> contents,
	int dst_i) {
	if (dst_i >= contents.size()) {
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Input data string contains more elements than the underlying "
	"buffer ("
	<< contents.size() << ")";
	}
	auto element_str = data_str.substr(token_start, token_end - token_start + 1);
	auto element = SimpleStrToValue<T>()(element_str);
	if (!element.has_value()) {
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Unable to parse element " << dst_i << " = '" << element_str
	<< "'";
	}
	contents[dst_i] = element.value();
	return OkStatus();
	}

	template <typename T>
	Status ParseNumericalDataAsType(absl::string_view data_str, Buffer* buffer) {
	ASSIGN_OR_RETURN(auto mapping,
	buffer->MapMemory<T>(MemoryAccess::kDiscardWrite));
	auto contents = mapping.mutable_contents();
	size_t src_i = 0;
	size_t dst_i = 0;
	size_t token_start = std::string::npos;
	while (src_i < data_str.size()) {
	char c = data_str[src_i++];
	bool is_separator =
	absl::ascii_isspace(c) \|\| c == ',' \|\| c == '[' \|\| c == ']';
	if (token_start == std::string::npos) {
	if (!is_separator) {
	token_start = src_i - 1;
	}
	continue;
	} else if (token_start != std::string::npos && !is_separator) {
	continue;
	}
	RETURN_IF_ERROR(ParseNumericalDataElement<T>(data_str, token_start,
	src_i - 2, contents, dst_i++));
	token_start = std::string::npos;
	}
	if (token_start != std::string::npos) {
	RETURN_IF_ERROR(ParseNumericalDataElement<T>(
	data_str, token_start, data_str.size() - 1, contents, dst_i++));
	}
	if (dst_i < contents.size()) {
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Input data string contains fewer elements than the underlying "
	"buffer (expected "
	<< contents.size() << ")";
	}
	return OkStatus();
	}

	// Parses numerical data (ints, floats, etc) in some typed form.
	Status ParseNumericalData(absl::string_view type_str,
	absl::string_view data_str, Buffer* buffer) {
	if (type_str == "i8") {
	return ParseNumericalDataAsType<int8_t>(data_str, buffer);
	} else if (type_str == "u8") {
	return ParseNumericalDataAsType<uint8_t>(data_str, buffer);
	} else if (type_str == "i16") {
	return ParseNumericalDataAsType<int16_t>(data_str, buffer);
	} else if (type_str == "u16") {
	return ParseNumericalDataAsType<uint16_t>(data_str, buffer);
	} else if (type_str == "i32") {
	return ParseNumericalDataAsType<int32_t>(data_str, buffer);
	} else if (type_str == "u32") {
	return ParseNumericalDataAsType<uint32_t>(data_str, buffer);
	} else if (type_str == "i64") {
	return ParseNumericalDataAsType<int64_t>(data_str, buffer);
	} else if (type_str == "u64") {
	return ParseNumericalDataAsType<uint64_t>(data_str, buffer);
	} else if (type_str == "f32") {
	return ParseNumericalDataAsType<float>(data_str, buffer);
	} else if (type_str == "f64") {
	return ParseNumericalDataAsType<double>(data_str, buffer);
	} else {
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Unsupported type: " << type_str;
	}
	}

	template <typename T>
	void PrintElementList(const Shape& shape, absl::Span<const T> data,
	size_t* max_entries, std::ostream* stream) {
	if (shape.empty()) {
	// Scalar value.
	PrintElementList({1}, data, max_entries, stream);
	return;
	} else if (shape.size() == 1) {
	// Leaf dimension; output data.
	size_t max_count = std::min(*max_entries, static_cast<size_t>(shape[0]));
	*stream << absl::StrJoin(data.subspan(0, max_count), " ");
	if (max_count < shape[0]) {
	*stream << "...";
	}
	*max_entries -= max_count;
	} else {
	// Nested; recurse into next dimension.
	Shape nested_shape = Shape(shape.subspan(1));
	size_t length = nested_shape.element_count();
	size_t offset = 0;
	for (int i = 0; i < shape[0]; ++i) {
	*stream << "[";
	PrintElementList<T>(nested_shape, data.subspan(offset, length),
	max_entries, stream);
	offset += length;
	*stream << "]";
	}
	}
	}

	template <typename T>
	Status PrintNumericalDataAsType(const Shape& shape, Buffer* buffer,
	size_t max_entries, std::ostream* stream) {
	ASSIGN_OR_RETURN(auto mapping, buffer->MapMemory<T>(MemoryAccess::kRead));
	PrintElementList(shape, mapping.contents(), &max_entries, stream);
	return OkStatus();
	}

	// Prints numerical data (ints, floats, etc) from some typed form.
	Status PrintNumericalData(const Shape& shape, absl::string_view type_str,
	Buffer* buffer, size_t max_entries,
	std::ostream* stream) {
	if (type_str == "i8") {
	return PrintNumericalDataAsType<int8_t>(shape, buffer, max_entries, stream);
	} else if (type_str == "u8") {
	return PrintNumericalDataAsType<uint8_t>(shape, buffer, max_entries,
	stream);
	} else if (type_str == "i16") {
	return PrintNumericalDataAsType<int16_t>(shape, buffer, max_entries,
	stream);
	} else if (type_str == "u16") {
	return PrintNumericalDataAsType<uint16_t>(shape, buffer, max_entries,
	stream);
	} else if (type_str == "i32") {
	return PrintNumericalDataAsType<int32_t>(shape, buffer, max_entries,
	stream);
	} else if (type_str == "u32") {
	return PrintNumericalDataAsType<uint32_t>(shape, buffer, max_entries,
	stream);
	} else if (type_str == "i64") {
	return PrintNumericalDataAsType<int64_t>(shape, buffer, max_entries,
	stream);
	} else if (type_str == "u64") {
	return PrintNumericalDataAsType<uint64_t>(shape, buffer, max_entries,
	stream);
	} else if (type_str == "f32") {
	return PrintNumericalDataAsType<float>(shape, buffer, max_entries, stream);
	} else if (type_str == "f64") {
	return PrintNumericalDataAsType<double>(shape, buffer, max_entries, stream);
	} else {
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Unsupported type: " << type_str;
	}
	}

	} // namespace

	StatusOr<int> GetTypeElementSize(absl::string_view type_str) {
	if (type_str.empty()) {
	return InvalidArgumentErrorBuilder(ABSL_LOC) << "Type is empty";
	} else if (IsBinaryType(type_str)) {
	// If the first character is a digit then we are dealign with binary data.
	// The type is just the number of bytes per element.
	int element_size = 0;
	if (!absl::SimpleAtoi(type_str, &element_size)) {
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Unable to parse element size type '" << type_str << "'";
	}
	return element_size;
	}
	// We know that our types are single characters followed by bit counts.
	// If we start to support other types we may need to do something more clever.
	int bit_count = 0;
	if (!absl::SimpleAtoi(type_str.substr(1), &bit_count)) {
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Unable to parse type bit count from '" << type_str
	<< "'; expecting something like 'i32'";
	}
	return bit_count / 8;
	}

	StatusOr<Shape> ParseShape(absl::string_view shape_str) {
	std::vector<int> dims;
	for (auto dim_str : absl::StrSplit(shape_str, 'x', absl::SkipWhitespace())) {
	int dim_value = 0;
	if (!absl::SimpleAtoi(dim_str, &dim_value)) {
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Invalid shape dimension '" << dim_str
	<< "' while parsing shape '" << shape_str << "'";
	}
	dims.push_back(dim_value);
	}
	return Shape{dims};
	}

	StatusOr<BufferView> ParseBufferViewFromString(
	absl::string_view buffer_view_str, hal::Allocator* allocator) {
	// Strip whitespace that may come along (linefeeds/etc).
	buffer_view_str = absl::StripAsciiWhitespace(buffer_view_str);
	if (buffer_view_str.empty()) {
	// Empty lines denote empty buffer_views.
	return BufferView{};
	}

	// Split into the components we can work with: shape, type, and data.
	absl::string_view shape_and_type_str;
	absl::string_view data_str;
	auto equal_index = buffer_view_str.find('=');
	if (equal_index == std::string::npos) {
	// Treat a lack of = as defaulting the data to zeros.
	shape_and_type_str = buffer_view_str;
	} else {
	shape_and_type_str = buffer_view_str.substr(0, equal_index);
	data_str = buffer_view_str.substr(equal_index + 1);
	}
	absl::string_view shape_str;
	absl::string_view type_str;
	auto last_x_index = shape_and_type_str.rfind('x');
	if (last_x_index == std::string::npos) {
	// Scalar.
	type_str = shape_and_type_str;
	} else {
	// Has a shape.
	shape_str = shape_and_type_str.substr(0, last_x_index);
	type_str = shape_and_type_str.substr(last_x_index + 1);
	}

	// Populate BufferView metadata required for allocation.
	BufferView result;
	ASSIGN_OR_RETURN(result.element_size, GetTypeElementSize(type_str));
	ASSIGN_OR_RETURN(result.shape, ParseShape(shape_str));

	// Allocate the host buffer.
	size_t allocation_size = result.shape.element_count() * result.element_size;
	if (allocator) {
	ASSIGN_OR_RETURN(
	result.buffer,
	allocator->Allocate(MemoryType::kHostLocal \| MemoryType::kDeviceVisible,
	BufferUsage::kAll \| BufferUsage::kConstant,
	allocation_size));
	} else {
	result.buffer = HeapBuffer::Allocate(
	MemoryType::kHostLocal, BufferUsage::kAll \| BufferUsage::kConstant,
	allocation_size);
	}

	if (!data_str.empty()) {
	// Parse the data from the string right into the buffer.
	if (IsBinaryType(type_str)) {
	// Parse as binary hex.
	RETURN_IF_ERROR(ParseBinaryData(data_str, result.buffer.get()));
	} else {
	// Parse as some nicely formatted type.
	RETURN_IF_ERROR(
	ParseNumericalData(type_str, data_str, result.buffer.get()));
	}
	}

	return result;
	}

	StatusOr<BufferViewPrintMode> ParseBufferViewPrintMode(absl::string_view str) {
	char str_char = str.empty() ? '?' : str[0];
	switch (str_char) {
	case 'b':
	return BufferViewPrintMode::kBinary;
	case 'i':
	return BufferViewPrintMode::kSignedInteger;
	case 'u':
	return BufferViewPrintMode::kUnsignedInteger;
	case 'f':
	return BufferViewPrintMode::kFloatingPoint;
	default:
	return InvalidArgumentErrorBuilder(ABSL_LOC)
	<< "Unsupported output type '" << str << "'";
	}
	}

	StatusOr<std::string> PrintBufferViewToString(const BufferView& buffer_view,
	BufferViewPrintMode print_mode,
	size_t max_entries) {
	std::string result;
	RETURN_IF_ERROR(
	PrintBufferViewToString(buffer_view, print_mode, max_entries, &result));
	return result;
	}

	Status PrintBufferViewToString(const BufferView& buffer_view,
	BufferViewPrintMode print_mode,
	size_t max_entries, std::string* out_result) {
	std::ostringstream stream;
	RETURN_IF_ERROR(
	PrintBufferViewToStream(buffer_view, print_mode, max_entries, &stream));
	*out_result = stream.str();
	return OkStatus();
	}

	Status PrintBufferViewToStream(const BufferView& buffer_view,
	BufferViewPrintMode print_mode,
	size_t max_entries, std::ostream* stream) {
	if (!buffer_view.buffer) {
	// No buffer means the buffer_view is empty. We use the empty string to
	// denote this (as we have no useful information).
	return OkStatus();
	}

	// Pick a type based on the element size and the printing mode.
	std::string type_str;
	switch (print_mode) {
	case BufferViewPrintMode::kBinary:
	type_str = std::to_string(buffer_view.element_size);
	break;
	case BufferViewPrintMode::kSignedInteger:
	absl::StrAppend(&type_str, "i", buffer_view.element_size * 8);
	break;
	case BufferViewPrintMode::kUnsignedInteger:
	absl::StrAppend(&type_str, "u", buffer_view.element_size * 8);
	break;
	case BufferViewPrintMode::kFloatingPoint:
	absl::StrAppend(&type_str, "f", buffer_view.element_size * 8);
	break;
	}

	// [shape]x[type]= prefix (taking into account scalar values).
	*stream << absl::StrJoin(buffer_view.shape.begin(), buffer_view.shape.end(),
	"x");
	if (!buffer_view.shape.empty()) *stream << "x";
	*stream << type_str;
	*stream << "=";

	if (IsBinaryType(type_str)) {
	return PrintBinaryData(buffer_view.element_size, buffer_view.buffer.get(),
	max_entries, stream);
	} else {
	return PrintNumericalData(buffer_view.shape, type_str,
	buffer_view.buffer.get(), max_entries, stream);
	}
	}

	} // namespace hal
	} // namespace iree