diff --git a/tflite/kernels/parse_example/example_proto_fast_parsing.cc b/tflite/kernels/parse_example/example_proto_fast_parsing.cc index 81eeec74fc..16bb2a23cc 100644 --- a/tflite/kernels/parse_example/example_proto_fast_parsing.cc +++ b/tflite/kernels/parse_example/example_proto_fast_parsing.cc @@ -20,7 +20,7 @@ limitations under the License. namespace tensorflow { namespace example { -string ExampleName(const absl::Span example_names, int n) { +std::string ExampleName(const absl::Span example_names, int n) { return example_names.empty() ? "" : example_names[n]; } @@ -62,19 +62,19 @@ void CopySparseBufferToTensor(DataType dtype, size_t offset, SparseBuffer* src, } } -uint8 PeekTag(protobuf::io::CodedInputStream* stream) { +uint8_t PeekTag(protobuf::io::CodedInputStream* stream) { DCHECK(stream != nullptr); const void* ptr; int size; if (!stream->GetDirectBufferPointer(&ptr, &size)) return 0; - return *static_cast(ptr); + return *static_cast(ptr); } bool ParseString(protobuf::io::CodedInputStream* stream, absl::string_view* result) { DCHECK(stream != nullptr); DCHECK(result != nullptr); - uint32 length; + uint32_t length; if (!stream->ReadVarint32(&length)) return false; if (length == 0) { *result = absl::string_view(nullptr, 0); @@ -85,7 +85,7 @@ bool ParseString(protobuf::io::CodedInputStream* stream, if (!stream->GetDirectBufferPointer(&stream_alias, &stream_size)) { return false; } - if (static_cast(stream_size) < length) return false; + if (static_cast(stream_size) < length) return false; *result = absl::string_view(static_cast(stream_alias), length); stream->Skip(length); return true; @@ -95,7 +95,7 @@ bool ParseFeatureMapEntry(protobuf::io::CodedInputStream* stream, parsed::FeatureMapEntry* feature_map_entry) { DCHECK(stream != nullptr); DCHECK(feature_map_entry != nullptr); - uint32 length; + uint32_t length; if (!stream->ReadVarint32(&length)) return false; auto limit = stream->PushLimit(length); if (!stream->ExpectTag(kDelimitedTag(1))) return false; @@ -113,7 +113,7 @@ bool ParseFeatures(protobuf::io::CodedInputStream* stream, parsed::Example* example) { DCHECK(stream != nullptr); DCHECK(example != nullptr); - uint32 length; + uint32_t length; if (!stream->ReadVarint32(&length)) return false; auto limit = stream->PushLimit(length); while (!stream->ExpectAtEnd()) { @@ -146,7 +146,7 @@ bool ParseExample(protobuf::io::CodedInputStream* stream, bool ParseExample(absl::string_view serialized, parsed::Example* example) { DCHECK(example != nullptr); protobuf::io::CodedInputStream stream( - reinterpret_cast(serialized.data()), serialized.size()); + reinterpret_cast(serialized.data()), serialized.size()); EnableAliasing(&stream); return ParseExample(&stream, example); } diff --git a/tflite/kernels/parse_example/example_proto_fast_parsing.h b/tflite/kernels/parse_example/example_proto_fast_parsing.h index 018e813a49..cc891eadb8 100644 --- a/tflite/kernels/parse_example/example_proto_fast_parsing.h +++ b/tflite/kernels/parse_example/example_proto_fast_parsing.h @@ -101,11 +101,11 @@ auto EnableAliasing(A* a) -> decltype(a->EnableAliasing(true), void()) { template void EnableAliasing(A&& a) {} -uint8 PeekTag(protobuf::io::CodedInputStream* stream); +uint8_t PeekTag(protobuf::io::CodedInputStream* stream); -constexpr uint8 kVarintTag(uint32 tag) { return (tag << 3) | 0; } -constexpr uint8 kDelimitedTag(uint32 tag) { return (tag << 3) | 2; } -constexpr uint8 kFixed32Tag(uint32 tag) { return (tag << 3) | 5; } +constexpr uint8_t kVarintTag(uint32_t tag) { return (tag << 3) | 0; } +constexpr uint8_t kDelimitedTag(uint32_t tag) { return (tag << 3) | 2; } +constexpr uint8_t kFixed32Tag(uint32_t tag) { return (tag << 3) | 5; } namespace parsed { @@ -121,7 +121,7 @@ class Feature { *dtype = DT_INVALID; return absl::OkStatus(); } - uint8 oneof_tag = static_cast(*serialized_.data()); + uint8_t oneof_tag = static_cast(*serialized_.data()); serialized_.remove_prefix(1); switch (oneof_tag) { case kDelimitedTag(1): @@ -143,15 +143,16 @@ class Feature { bool GetNumElementsInBytesList(int* num_elements) { protobuf::io::CodedInputStream stream( - reinterpret_cast(serialized_.data()), serialized_.size()); + reinterpret_cast(serialized_.data()), + serialized_.size()); EnableAliasing(&stream); - uint32 length = 0; + uint32_t length = 0; if (!stream.ReadVarint32(&length)) return false; auto limit = stream.PushLimit(length); *num_elements = 0; while (!stream.ExpectAtEnd()) { if (!stream.ExpectTag(kDelimitedTag(1))) return false; - uint32 bytes_length = 0; + uint32_t bytes_length = 0; if (!stream.ReadVarint32(&bytes_length)) return false; if (!stream.Skip(bytes_length)) return false; ++*num_elements; @@ -176,18 +177,19 @@ class Feature { DCHECK(bytes_list != nullptr); protobuf::io::CodedInputStream stream( - reinterpret_cast(serialized_.data()), serialized_.size()); + reinterpret_cast(serialized_.data()), + serialized_.size()); EnableAliasing(&stream); - uint32 length; + uint32_t length; if (!stream.ReadVarint32(&length)) return false; auto limit = stream.PushLimit(length); while (!stream.ExpectAtEnd()) { if (!stream.ExpectTag(kDelimitedTag(1))) return false; // parse string - uint32 bytes_length; + uint32_t bytes_length; if (!stream.ReadVarint32(&bytes_length)) return false; tstring* bytes = construct_at_end(bytes_list); if (bytes == nullptr) return false; @@ -202,14 +204,15 @@ class Feature { bool ParseFloatList(Result* float_list) { DCHECK(float_list != nullptr); protobuf::io::CodedInputStream stream( - reinterpret_cast(serialized_.data()), serialized_.size()); + reinterpret_cast(serialized_.data()), + serialized_.size()); EnableAliasing(&stream); - uint32 length; + uint32_t length; if (!stream.ReadVarint32(&length)) return false; auto limit = stream.PushLimit(length); if (!stream.ExpectAtEnd()) { - uint8 peek_tag = PeekTag(&stream); + uint8_t peek_tag = PeekTag(&stream); if (peek_tag != kDelimitedTag(1) && peek_tag != kFixed32Tag(1)) { return false; } @@ -217,7 +220,7 @@ class Feature { constexpr int32_t kNumFloatBytes = 4; if (peek_tag == kDelimitedTag(1)) { // packed if (!stream.ExpectTag(kDelimitedTag(1))) return false; // packed tag - uint32 packed_length; + uint32_t packed_length; if (!stream.ReadVarint32(&packed_length)) return false; auto packed_limit = stream.PushLimit(packed_length); @@ -233,16 +236,16 @@ class Feature { sizeof(typename Result::value_type) == kNumFloatBytes) { // Calculate the length of the buffer available what can be less than // what we requested in resize in case of a LimitedArraySlice. - const uint32 bytes_to_copy = - std::min(static_cast((float_list->size() - initial_size) * - kNumFloatBytes), - packed_length); + const uint32_t bytes_to_copy = std::min( + static_cast((float_list->size() - initial_size) * + kNumFloatBytes), + packed_length); if (!stream.ReadRaw(float_list->data() + initial_size, bytes_to_copy)) return false; } else { int64_t index = initial_size; while (!stream.ExpectAtEnd()) { - uint32 buffer32; + uint32_t buffer32; if (!stream.ReadLittleEndian32(&buffer32)) return false; if (index < float_list->size()) { float_list->data()[index] = absl::bit_cast(buffer32); @@ -262,7 +265,7 @@ class Feature { int64_t index = initial_size; while (!stream.ExpectAtEnd()) { if (!stream.ExpectTag(kFixed32Tag(1))) return false; - uint32 buffer32; + uint32_t buffer32; if (!stream.ReadLittleEndian32(&buffer32)) return false; float_list->data()[index] = absl::bit_cast(buffer32); ++index; @@ -278,20 +281,21 @@ class Feature { bool ParseInt64List(Result* int64_list) { DCHECK(int64_list != nullptr); protobuf::io::CodedInputStream stream( - reinterpret_cast(serialized_.data()), serialized_.size()); + reinterpret_cast(serialized_.data()), + serialized_.size()); EnableAliasing(&stream); - uint32 length; + uint32_t length; if (!stream.ReadVarint32(&length)) return false; auto limit = stream.PushLimit(length); if (!stream.ExpectAtEnd()) { - uint8 peek_tag = PeekTag(&stream); + uint8_t peek_tag = PeekTag(&stream); if (peek_tag != kDelimitedTag(1) && peek_tag != kVarintTag(1)) { return false; } if (peek_tag == kDelimitedTag(1)) { // packed if (!stream.ExpectTag(kDelimitedTag(1))) return false; // packed tag - uint32 packed_length; + uint32_t packed_length; if (!stream.ReadVarint32(&packed_length)) return false; auto packed_limit = stream.PushLimit(packed_length); @@ -327,7 +331,7 @@ using Example = std::vector; } // namespace parsed inline bool SkipExtraneousTag(protobuf::io::CodedInputStream* stream) { - uint32 data; + uint32_t data; protobuf_uint64 dummy; switch (stream->ReadTag() & 0x7) { case 0: // varint @@ -387,10 +391,10 @@ struct SparseBuffer { }; struct SeededHasher { - uint64 operator()(absl::string_view s) const { + uint64_t operator()(absl::string_view s) const { return Hash64(s.data(), s.size(), seed); } - uint64 seed{0xDECAFCAFFE}; + uint64_t seed{0xDECAFCAFFE}; }; // Use this in the "default" clause of switch statements when dispatching @@ -451,21 +455,21 @@ struct FeatureProtos { // Map from feature name to FeatureProtos for that feature. using FeatureProtosMap = absl::flat_hash_map; -string ExampleName(const absl::Span example_names, int n); +std::string ExampleName(const absl::Span example_names, int n); // Return the number of bytes elements parsed, or -1 on error. If out is null, // this method simply counts the number of elements without any copying. inline int ParseBytesFeature(protobuf::io::CodedInputStream* stream, tstring* out) { int num_elements = 0; - uint32 length; + uint32_t length; if (!stream->ExpectTag(kDelimitedTag(1)) || !stream->ReadVarint32(&length)) { return -1; } if (length > 0) { auto limit = stream->PushLimit(length); while (!stream->ExpectAtEnd()) { - uint32 bytes_length; + uint32_t bytes_length; if (!stream->ExpectTag(kDelimitedTag(1)) || !stream->ReadVarint32(&bytes_length)) { return -1; @@ -503,22 +507,22 @@ inline void PadInt64Feature(int num_to_pad, int64_t* out) { inline int ParseFloatFeature(protobuf::io::CodedInputStream* stream, float* out) { int num_elements = 0; - uint32 length; + uint32_t length; if (!stream->ExpectTag(kDelimitedTag(2)) || !stream->ReadVarint32(&length)) { return -1; } if (length > 0) { auto limit = stream->PushLimit(length); - uint8 peek_tag = PeekTag(stream); + uint8_t peek_tag = PeekTag(stream); if (peek_tag == kDelimitedTag(1)) { // packed - uint32 packed_length; + uint32_t packed_length; if (!stream->ExpectTag(kDelimitedTag(1)) || !stream->ReadVarint32(&packed_length)) { return -1; } auto packed_limit = stream->PushLimit(packed_length); while (!stream->ExpectAtEnd()) { - uint32 buffer32; + uint32_t buffer32; if (!stream->ReadLittleEndian32(&buffer32)) { return -1; } @@ -530,7 +534,7 @@ inline int ParseFloatFeature(protobuf::io::CodedInputStream* stream, stream->PopLimit(packed_limit); } else if (peek_tag == kFixed32Tag(1)) { while (!stream->ExpectAtEnd()) { - uint32 buffer32; + uint32_t buffer32; if (!stream->ExpectTag(kFixed32Tag(1)) || !stream->ReadLittleEndian32(&buffer32)) { return -1; @@ -554,15 +558,15 @@ inline int ParseFloatFeature(protobuf::io::CodedInputStream* stream, inline int ParseInt64Feature(protobuf::io::CodedInputStream* stream, int64_t* out) { int num_elements = 0; - uint32 length; + uint32_t length; if (!stream->ExpectTag(kDelimitedTag(3)) || !stream->ReadVarint32(&length)) { return -1; } if (length > 0) { auto limit = stream->PushLimit(length); - uint8 peek_tag = PeekTag(stream); + uint8_t peek_tag = PeekTag(stream); if (peek_tag == kDelimitedTag(1)) { // packed - uint32 packed_length; + uint32_t packed_length; if (!stream->ExpectTag(kDelimitedTag(1)) || !stream->ReadVarint32(&packed_length)) { return -1; @@ -646,7 +650,7 @@ inline int GetFeatureLength(DataType dtype, } inline DataType ParseDataType(protobuf::io::CodedInputStream* stream) { - uint8 peek_tag = PeekTag(stream); + uint8_t peek_tag = PeekTag(stream); switch (peek_tag) { case kDelimitedTag(1): return DT_STRING; @@ -680,7 +684,7 @@ inline bool SkipEmptyFeature(protobuf::io::CodedInputStream* stream, default: return false; } - uint32 length; + uint32_t length; return stream->ReadVarint32(&length) && length == 0; }