[Chore](hash) use google/crc32c to instead rocksdb/crc32c and crc_hash (#58557)

doris have crc32c from rocksdb now, but it has poorly performance than
google/crc32c.

66663538 rows int
crc32c-rocksdb 684.879ms
crc32c-google 206.360ms

66663538 rows varchar
crc32c-rocksdb 1sec368ms
crc32c-google 391.290ms

We already have unit tests for
rocksdb/crc32c([be/test/util/crc32c_test.cpp](https://github.com/apache/doris/blob/master/be/test/util/crc32c_test.cpp)),
so this change is safe

This pull request updates the codebase to use the more efficient and
modern CRC32C hashing algorithm in place of the older CRC32
implementation. The changes include switching hash functions throughout
the code, updating the CRC32C utility implementation to use an external
library, and adding the required third-party dependency. This improves
hash performance and consistency, and prepares the codebase for future
compatibility.

**Hashing algorithm migration:**

* Replaced all usages of `HashUtil::crc_hash` with
`HashUtil::crc32c_hash` in `block_bloom_filter.hpp`,
`column_dictionary.h`, and `function_string.h` to utilize CRC32C for
better performance and reliability.
[[1]](diffhunk://#diff-635476edd1321096d1d32eb6453bed4624e8f23d0580750d515aaad9dfe5404eL79-R79)
[[2]](diffhunk://#diff-635476edd1321096d1d32eb6453bed4624e8f23d0580750d515aaad9dfe5404eL108-R108)
[[3]](diffhunk://#diff-bf8bb38b6a6eae6cccd7ed62ff64b1a77fbd273a614348b096330abea8331b4dL348-R348)
[[4]](diffhunk://#diff-9cc694af32a330f9ffd947df039bdfc12be67b2107c9e612d7861b17c5018176L4601-R4601)

* Added the new `crc32c_hash` method to `HashUtil` and marked the old
`crc_hash` as deprecated, retaining it only for backward compatibility
with historical data.
[[1]](diffhunk://#diff-92d951e58f5e0b824254f5eb0d931b604518e4bfbe666b665cd56ed9435667bbL52-R58)
[[2]](diffhunk://#diff-92d951e58f5e0b824254f5eb0d931b604518e4bfbe666b665cd56ed9435667bbR68-R69)
[[3]](diffhunk://#diff-92d951e58f5e0b824254f5eb0d931b604518e4bfbe666b665cd56ed9435667bbL120-L124)

**CRC32C utility refactor and dependency management:**

* Refactored `crc32c.cpp` and `crc32c.h` to use the external `crc32c`
library, removing the previous custom implementation and lookup tables.
Added new utility functions for CRC32C operations.
[[1]](diffhunk://#diff-1a21d70259827997bdfd54da21acd6db2ae0a29465873b53dbf8c7e9c6a7e265L18-R38)
[[2]](diffhunk://#diff-72d5c6ec3fe2da095fe1413472778c1d56027242035bdb83c62339ccfcca6ed6L18-R33)

* Added the `crc32c` third-party dependency in the build configuration
to support the new CRC32C utility.

**Build and header updates:**

* Updated includes in `hash_util.hpp` to reference the new CRC32C
utility.

Author: BiteTheDDDDt

be/cmake/thirdparty.cmake

@@ -68,6 +68,7 @@ add_thirdparty(curl)
 add_thirdparty(lz4)
 add_thirdparty(thrift)
 add_thirdparty(thriftnb)
+add_thirdparty(crc32c)
 
 add_thirdparty(libevent_core LIBNAME "lib/libevent_core.a")
 add_thirdparty(libevent_openssl LIBNAME "lib/libevent_openssl.a")

be/src/exprs/block_bloom_filter.hpp

@@ -76,7 +76,7 @@ class BlockBloomFilter {
     // Same as above with convenience of hashing the key.
     void insert(const StringRef& key) noexcept {
         if (key.data) {
-            insert(HashUtil::crc_hash(key.data, uint32_t(key.size), _hash_seed));
+            insert(HashUtil::crc32c_hash(key.data, uint32_t(key.size), _hash_seed));
         }
     }
 
@@ -105,7 +105,7 @@ class BlockBloomFilter {
     // Same as above with convenience of hashing the key.
     bool find(const StringRef& key) const noexcept {
         if (key.data) {
-            return find(HashUtil::crc_hash(key.data, uint32_t(key.size), _hash_seed));
+            return find(HashUtil::crc32c_hash(key.data, uint32_t(key.size), _hash_seed));
         }
         return false;
     }

be/src/util/crc32c.cpp

@@ -15,39 +15,22 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// the following code are modified from RocksDB:
-// https://github.com/facebook/rocksdb/blob/master/util/crc32c.h
-
 #pragma once
 
-#include <stddef.h>
-#include <stdint.h>
-
 #include <vector>
 
 #include "util/slice.h"
 
 namespace doris {
 namespace crc32c {
 
-// Return the crc32c of concat(A, data[0,n-1]) where init_crc is the
-// crc32c of some string A.  Extend() is often used to maintain the
-// crc32c of a stream of data.
-extern uint32_t Extend(uint32_t init_crc, const char* data, size_t n);
+uint32_t Extend(uint32_t crc, const char* data, size_t n);
 
 // Return the crc32c of data[0,n-1]
-inline uint32_t Value(const char* data, size_t n) {
-    return Extend(0, data, n);
-}
+uint32_t Value(const char* data, size_t n);
 
 // Return the crc32c of data content in all slices
-inline uint32_t Value(const std::vector<Slice>& slices) {
-    uint32_t crc = 0;
-    for (auto& slice : slices) {
-        crc = Extend(crc, slice.get_data(), slice.get_size());
-    }
-    return crc;
-}
+uint32_t Value(const std::vector<Slice>& slices);
 
 } // namespace crc32c
 } // namespace doris

be/src/util/crc32c.h

@@ -30,6 +30,7 @@
 
 #include "common/compiler_util.h" // IWYU pragma: keep
 #include "util/cpu_info.h"
+#include "util/crc32c.h"
 #include "util/hash/city.h"
 #include "util/murmur_hash3.h"
 #include "util/sse_util.hpp"
@@ -49,7 +50,12 @@ class HashUtil {
         return (uint32_t)crc32(hash, (const unsigned char*)(&INT_VALUE), 4);
     }
 
-#if defined(__SSE4_2__) || defined(__aarch64__)
+    // ATTN: crc32c's result is different with zlib_crc32 coz of different polynomial
+    // crc32c have better performance than zlib_crc32/crc_hash
+    static uint32_t crc32c_hash(const void* data, uint32_t bytes, uint32_t hash) {
+        return crc32c::Extend(hash, static_cast<const char*>(data), bytes);
+    }
+
     // Compute the Crc32 hash for data using SSE4 instructions.  The input hash parameter is
     // the current hash/seed value.
     // This should only be called if SSE is supported.
@@ -59,6 +65,8 @@ class HashUtil {
     // NOTE: Any changes made to this function need to be reflected in Codegen::GetHashFn.
     // TODO: crc32 hashes with different seeds do not result in different hash functions.
     // The resulting hashes are correlated.
+    // ATTN: prefer do not use this function anymore, use crc32c_hash instead
+    // This function is retained because it is not certain whether there are compatibility issues with historical data.
     static uint32_t crc_hash(const void* data, uint32_t bytes, uint32_t hash) {
         if (!CpuInfo::is_supported(CpuInfo::SSE4_2)) {
             return zlib_crc_hash(data, bytes, hash);
@@ -117,11 +125,6 @@ class HashUtil {
 
         return converter.u64;
     }
-#else
-    static uint32_t crc_hash(const void* data, uint32_t bytes, uint32_t hash) {
-        return zlib_crc_hash(data, bytes, hash);
-    }
-#endif
 
     // refer to https://github.com/apache/commons-codec/blob/master/src/main/java/org/apache/commons/codec/digest/MurmurHash3.java
     static const uint32_t MURMUR3_32_SEED = 104729;

be/src/util/hash_util.hpp

@@ -345,7 +345,7 @@ class ColumnDictI32 final : public COWHelper<IColumn, ColumnDictI32> {
                 if (type == FieldType::OLAP_FIELD_TYPE_CHAR) {
                     len = strnlen(sv.data, sv.size);
                 }
-                uint32_t hash_val = HashUtil::crc_hash(sv.data, static_cast<uint32_t>(len), 0);
+                uint32_t hash_val = HashUtil::crc32c_hash(sv.data, static_cast<uint32_t>(len), 0);
                 _hash_values[code] = hash_val;
                 _compute_hash_value_flags[code] = 1;
                 return _hash_values[code];

be/src/vec/columns/column_dictionary.h

@@ -4598,7 +4598,7 @@ class FunctionNgramSearch : public IFunction {
 
     uint32_t sub_str_hash(const char* data, int32_t length) const {
         constexpr static uint32_t seed = 0;
-        return HashUtil::crc_hash(data, length, seed);
+        return HashUtil::crc32c_hash(data, length, seed);
     }
 
     template <bool column_const>