Merge changes I90056145,Ib123d069 into main (90d04343) · Commits · e / os / android_frameworks_native

include/ftl/details/hash.h

0 → 100644

+119 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2024 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#pragma once

		#include <cinttypes>
		#include <cstring>

		namespace android::ftl::details {

		// Based on CityHash64 v1.0.1 (http://code.google.com/p/cityhash/), but slightly
		// modernized and trimmed for cases with bounded lengths.

		template <typename T = std::uint64_t>
		inline T read_unaligned(const void* ptr) {
		T v;
		std::memcpy(&v, ptr, sizeof(T));
		return v;
		}

		template <bool NonZeroShift = false>
		constexpr std::uint64_t rotate(std::uint64_t v, std::uint8_t shift) {
		if constexpr (!NonZeroShift) {
		if (shift == 0) return v;
		}
		return (v >> shift) \| (v << (64 - shift));
		}

		constexpr std::uint64_t shift_mix(std::uint64_t v) {
		return v ^ (v >> 47);
		}

		constexpr std::uint64_t hash_length_16(std::uint64_t u, std::uint64_t v) {
		constexpr std::uint64_t kPrime = 0x9ddfea08eb382d69ull;
		auto a = (u ^ v) * kPrime;
		a ^= (a >> 47);
		auto b = (v ^ a) * kPrime;
		b ^= (b >> 47);
		b *= kPrime;
		return b;
		}

		constexpr std::uint64_t kPrime0 = 0xc3a5c85c97cb3127ull;
		constexpr std::uint64_t kPrime1 = 0xb492b66fbe98f273ull;
		constexpr std::uint64_t kPrime2 = 0x9ae16a3b2f90404full;
		constexpr std::uint64_t kPrime3 = 0xc949d7c7509e6557ull;

		inline std::uint64_t hash_length_0_to_16(const char* str, std::uint64_t length) {
		if (length > 8) {
		const auto a = read_unaligned(str);
		const auto b = read_unaligned(str + length - 8);
		return hash_length_16(a, rotate<true>(b + length, static_cast<std::uint8_t>(length))) ^ b;
		}
		if (length >= 4) {
		const auto a = read_unaligned<std::uint32_t>(str);
		const auto b = read_unaligned<std::uint32_t>(str + length - 4);
		return hash_length_16(length + (a << 3), b);
		}
		if (length > 0) {
		const auto a = static_cast<unsigned char>(str[0]);
		const auto b = static_cast<unsigned char>(str[length >> 1]);
		const auto c = static_cast<unsigned char>(str[length - 1]);
		const auto y = static_cast<std::uint32_t>(a) + (static_cast<std::uint32_t>(b) << 8);
		const auto z = static_cast<std::uint32_t>(length) + (static_cast<std::uint32_t>(c) << 2);
		return shift_mix(y * kPrime2 ^ z * kPrime3) * kPrime2;
		}
		return kPrime2;
		}

		inline std::uint64_t hash_length_17_to_32(const char* str, std::uint64_t length) {
		const auto a = read_unaligned(str) * kPrime1;
		const auto b = read_unaligned(str + 8);
		const auto c = read_unaligned(str + length - 8) * kPrime2;
		const auto d = read_unaligned(str + length - 16) * kPrime0;
		return hash_length_16(rotate(a - b, 43) + rotate(c, 30) + d,
		a + rotate(b ^ kPrime3, 20) - c + length);
		}

		inline std::uint64_t hash_length_33_to_64(const char* str, std::uint64_t length) {
		auto z = read_unaligned(str + 24);
		auto a = read_unaligned(str) + (length + read_unaligned(str + length - 16)) * kPrime0;
		auto b = rotate(a + z, 52);
		auto c = rotate(a, 37);

		a += read_unaligned(str + 8);
		c += rotate(a, 7);
		a += read_unaligned(str + 16);

		const auto vf = a + z;
		const auto vs = b + rotate(a, 31) + c;

		a = read_unaligned(str + 16) + read_unaligned(str + length - 32);
		z += read_unaligned(str + length - 8);
		b = rotate(a + z, 52);
		c = rotate(a, 37);
		a += read_unaligned(str + length - 24);
		c += rotate(a, 7);
		a += read_unaligned(str + length - 16);

		const auto wf = a + z;
		const auto ws = b + rotate(a, 31) + c;
		const auto r = shift_mix((vf + ws) * kPrime2 + (wf + vs) * kPrime0);
		return shift_mix(r * kPrime0 + vs) * kPrime2;
		}

		} // namespace android::ftl::details

include/ftl/hash.h

0 → 100644

+44 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2024 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#pragma once

		#include <cinttypes>
		#include <optional>
		#include <string_view>

		#include <ftl/details/hash.h>

		namespace android::ftl {

		// Non-cryptographic hash function (namely CityHash64) for strings with at most 64 characters.
		// Unlike std::hash, which returns std::size_t and is only required to produce the same result
		// for the same input within a single execution of a program, this hash is stable.
		inline std::optional<std::uint64_t> stable_hash(std::string_view view) {
		const auto length = view.length();
		if (length <= 16) {
		return details::hash_length_0_to_16(view.data(), length);
		}
		if (length <= 32) {
		return details::hash_length_17_to_32(view.data(), length);
		}
		if (length <= 64) {
		return details::hash_length_33_to_64(view.data(), length);
		}
		return {};
		}

		} // namespace android::ftl

libs/ftl/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@ cc_test {
		"flags_test.cpp",
		"function_test.cpp",
		"future_test.cpp",
		"hash_test.cpp",
		"match_test.cpp",
		"mixins_test.cpp",
		"non_null_test.cpp",

libs/ftl/hash_test.cpp

0 → 100644

+40 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2024 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <ftl/hash.h>
		#include <gtest/gtest.h>

		#include <numeric>
		#include <string>

		namespace android::test {

		TEST(Hash, StableHash) {
		EXPECT_EQ(11160318154034397263ull, (ftl::stable_hash({})));

		std::string string(64, '?');
		std::iota(string.begin(), string.end(), 'A');

		// Maximum length is 64 characters.
		EXPECT_FALSE(ftl::stable_hash(string + '\n'));

		EXPECT_EQ(6278090252846864564ull, ftl::stable_hash(std::string_view(string).substr(0, 8)));
		EXPECT_EQ(1883356980931444616ull, ftl::stable_hash(std::string_view(string).substr(0, 16)));
		EXPECT_EQ(8073093283835059304ull, ftl::stable_hash(std::string_view(string).substr(0, 32)));
		EXPECT_EQ(18197365392429149980ull, ftl::stable_hash(string));
		}

		} // namespace android::test

libs/ui/DisplayIdentification.cpp

+2 −65

Original line number	Diff line number	Diff line
		@@ -23,67 +23,13 @@
		#include <optional>
		#include <span>

		#include <ftl/hash.h>
		#include <log/log.h>

		#include <ui/DisplayIdentification.h>

		namespace android {
		namespace {

		template <class T>
		inline T load(const void* p) {
		static_assert(std::is_integral<T>::value, "T must be integral");

		T r;
		std::memcpy(&r, p, sizeof(r));
		return r;
		}

		uint64_t rotateByAtLeast1(uint64_t val, uint8_t shift) {
		return (val >> shift) \| (val << (64 - shift));
		}

		uint64_t shiftMix(uint64_t val) {
		return val ^ (val >> 47);
		}

		__attribute__((no_sanitize("unsigned-integer-overflow")))
		uint64_t hash64Len16(uint64_t u, uint64_t v) {
		constexpr uint64_t kMul = 0x9ddfea08eb382d69;
		uint64_t a = (u ^ v) * kMul;
		a ^= (a >> 47);
		uint64_t b = (v ^ a) * kMul;
		b ^= (b >> 47);
		b *= kMul;
		return b;
		}

		__attribute__((no_sanitize("unsigned-integer-overflow")))
		uint64_t hash64Len0To16(const char* s, uint64_t len) {
		constexpr uint64_t k2 = 0x9ae16a3b2f90404f;
		constexpr uint64_t k3 = 0xc949d7c7509e6557;

		if (len > 8) {
		const uint64_t a = load<uint64_t>(s);
		const uint64_t b = load<uint64_t>(s + len - 8);
		return hash64Len16(a, rotateByAtLeast1(b + len, static_cast<uint8_t>(len))) ^ b;
		}
		if (len >= 4) {
		const uint32_t a = load<uint32_t>(s);
		const uint32_t b = load<uint32_t>(s + len - 4);
		return hash64Len16(len + (a << 3), b);
		}
		if (len > 0) {
		const unsigned char a = static_cast<unsigned char>(s[0]);
		const unsigned char b = static_cast<unsigned char>(s[len >> 1]);
		const unsigned char c = static_cast<unsigned char>(s[len - 1]);
		const uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8);
		const uint32_t z = static_cast<uint32_t>(len) + (static_cast<uint32_t>(c) << 2);
		return shiftMix(y * k2 ^ z * k3) * k2;
		}
		return k2;
		}

		using byte_view = std::span<const uint8_t>;

		constexpr size_t kEdidBlockSize = 128;
		@@ -320,7 +266,7 @@ std::optional<Edid> parseEdid(const DisplayIdentificationData& edid) {
		// Hash model string instead of using product code or (integer) serial number, since the latter
		// have been observed to change on some displays with multiple inputs. Use a stable hash instead
		// of std::hash which is only required to be same within a single execution of a program.
		const uint32_t modelHash = static_cast<uint32_t>(cityHash64Len0To16(modelString));
		const uint32_t modelHash = static_cast<uint32_t>(*ftl::stable_hash(modelString));

		// Parse extension blocks.
		std::optional<Cea861ExtensionBlock> cea861Block;
		@@ -394,13 +340,4 @@ PhysicalDisplayId getVirtualDisplayId(uint32_t id) {
		return PhysicalDisplayId::fromEdid(0, kVirtualEdidManufacturerId, id);
		}

		uint64_t cityHash64Len0To16(std::string_view sv) {
		auto len = sv.length();
		if (len > 16) {
		ALOGE("%s called with length %zu. Only hashing the first 16 chars", __FUNCTION__, len);
		len = 16;
		}
		return hash64Len0To16(sv.data(), len);
		}

		} // namespace android