@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/crc/internal/gen_crc32c_consts.py

@@ -1,90 +0,0 @@
-#!/usr/bin/env python3
-#
-# Copyright 2025 The Abseil Authors.
-#
-# 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.
-
-"""This script generates kCRC32CPowers[]."""
-
-
-def poly_mul(a, b):
-  """Polynomial multiplication: a * b."""
-  product = 0
-  for i in range(b.bit_length()):
-    if (b & (1 << i)) != 0:
-      product ^= a << i
-  return product
-
-
-def poly_div(a, b):
-  """Polynomial division: floor(a / b)."""
-  q = 0
-  while a.bit_length() >= b.bit_length():
-    q ^= 1 << (a.bit_length() - b.bit_length())
-    a ^= b << (a.bit_length() - b.bit_length())
-  return q
-
-
-def poly_reduce(a, b):
-  """Polynomial reduction: a mod b."""
-  return a ^ poly_mul(poly_div(a, b), b)
-
-
-def poly_exp(a, b, g):
-  """Polynomial exponentiation: a^b mod g."""
-  if b == 1:
-    return poly_reduce(a, g)
-  c = poly_exp(a, b // 2, g)
-  c = poly_mul(c, c)
-  if b % 2 != 0:
-    c = poly_mul(c, a)
-  return poly_reduce(c, g)
-
-
-def bitreflect(a, num_bits):
-  """Reflects the bits of the given integer."""
-  if a.bit_length() > num_bits:
-    raise ValueError(f'Integer has more than {num_bits} bits')
-  return sum(((a >> i) & 1) << (num_bits - 1 - i) for i in range(num_bits))
-
-
-G = 0x11EDC6F41  # The CRC-32C reducing polynomial, in the "natural" bit order
-CRC_BITS = 32  # The degree of G, i.e. the 32 in "CRC-32C"
-LSB_FIRST = True  # CRC-32C is a least-significant-bit-first CRC
-NUM_SIZE_BITS = 64  # The maximum number of bits in the length (size_t)
-NUM_DROPPED_BITS = 4  # The number of bits dropped from the length
-LOG2_BITS_PER_BYTE = 3  # log2 of the number of bits in a byte, i.e. log2(8)
-X = 2  # The polynomial 'x', in the "natural" bit order
-
-
-def print_crc32c_powers():
-  """Generates kCRC32CPowers[].
-
-  kCRC32CPowers[] is an array of length NUM_SIZE_BITS - NUM_DROPPED_BITS,
-  whose i'th entry is x^(2^(i + LOG2_BITS_PER_BYTE + NUM_DROPPED_BITS) -
-  CRC_BITS - 1) mod G. See kCRC32CPowers[] in the C++ source for more info.
-  """
-  for i in range(NUM_SIZE_BITS - NUM_DROPPED_BITS):
-    poly = poly_exp(
-        X,
-        2 ** (i + LOG2_BITS_PER_BYTE + NUM_DROPPED_BITS)
-        - CRC_BITS
-        - (1 if LSB_FIRST else 0),
-        G,
-    )
-    poly = bitreflect(poly, CRC_BITS)
-    print(f'0x{poly:0{2*CRC_BITS//8}x}, ', end='')
-
-
-if __name__ == '__main__':
-  print_crc32c_powers()

package/deps/abseil-cpp/absl/crc/internal/non_temporal_arm_intrinsics.h

@@ -1,81 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// 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.
-
-// SKIP_ABSL_INLINE_NAMESPACE_CHECK
-
-#ifndef ABSL_CRC_INTERNAL_NON_TEMPORAL_ARM_INTRINSICS_H_
-#define ABSL_CRC_INTERNAL_NON_TEMPORAL_ARM_INTRINSICS_H_
-
-#include "absl/base/config.h"
-
-#ifdef __aarch64__
-#include <arm_neon.h>
-
-typedef int64x2_t __m128i; /* 128-bit vector containing integers */
-#define vreinterpretq_m128i_s64(x) (x)
-#define vreinterpretq_s64_m128i(x) (x)
-
-// Guarantees that every preceding store is globally visible before any
-// subsequent store.
-// https://msdn.microsoft.com/en-us/library/5h2w73d1%28v=vs.90%29.aspx
-static inline __attribute__((always_inline)) void _mm_sfence(void) {
-  __sync_synchronize();
-}
-
-// Load 128-bits of integer data from unaligned memory into dst. This intrinsic
-// may perform better than _mm_loadu_si128 when the data crosses a cache line
-// boundary.
-//
-//   dst[127:0] := MEM[mem_addr+127:mem_addr]
-//
-// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_lddqu_si128
-#define _mm_lddqu_si128 _mm_loadu_si128
-
-// Loads 128-bit value. :
-// https://msdn.microsoft.com/zh-cn/library/f4k12ae8(v=vs.90).aspx
-static inline __attribute__((always_inline)) __m128i _mm_loadu_si128(
-    const __m128i *p) {
-  return vreinterpretq_m128i_s64(vld1q_s64((const int64_t*)p));
-}
-
-// Stores the data in a to the address p without polluting the caches.  If the
-// cache line containing address p is already in the cache, the cache will be
-// updated.
-// https://msdn.microsoft.com/en-us/library/ba08y07y%28v=vs.90%29.aspx
-static inline __attribute__((always_inline)) void _mm_stream_si128(__m128i *p,
-                                                                   __m128i a) {
-#if ABSL_HAVE_BUILTIN(__builtin_nontemporal_store)
-  __builtin_nontemporal_store(a, p);
-#else
-  vst1q_s64((int64_t *)p, vreinterpretq_s64_m128i(a));
-#endif
-}
-
-// Sets the 16 signed 8-bit integer values.
-// https://msdn.microsoft.com/en-us/library/x0cx8zd3(v=vs.90).aspx
-static inline __attribute__((always_inline)) __m128i _mm_set_epi8(
-    signed char b15, signed char b14, signed char b13, signed char b12,
-    signed char b11, signed char b10, signed char b9, signed char b8,
-    signed char b7, signed char b6, signed char b5, signed char b4,
-    signed char b3, signed char b2, signed char b1, signed char b0) {
-  int8_t __attribute__((aligned(16)))
-  data[16] = {(int8_t)b0,  (int8_t)b1,  (int8_t)b2,  (int8_t)b3,
-              (int8_t)b4,  (int8_t)b5,  (int8_t)b6,  (int8_t)b7,
-              (int8_t)b8,  (int8_t)b9,  (int8_t)b10, (int8_t)b11,
-              (int8_t)b12, (int8_t)b13, (int8_t)b14, (int8_t)b15};
-  return (__m128i)vld1q_s8(data);
-}
-#endif  // __aarch64__
-
-#endif  // ABSL_CRC_INTERNAL_NON_TEMPORAL_ARM_INTRINSICS_H_

package/deps/abseil-cpp/absl/crc/internal/non_temporal_memcpy.h

@@ -1,195 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// 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.
-
-#ifndef ABSL_CRC_INTERNAL_NON_TEMPORAL_MEMCPY_H_
-#define ABSL_CRC_INTERNAL_NON_TEMPORAL_MEMCPY_H_
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-#if defined(__SSE__) || defined(__AVX__)
-// Pulls in both SSE and AVX intrinsics.
-#include <immintrin.h>
-#endif
-
-#ifdef __aarch64__
-#include "absl/crc/internal/non_temporal_arm_intrinsics.h"
-#endif
-
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <cstring>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/optimization.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace crc_internal {
-
-// This non-temporal memcpy does regular load and non-temporal store memory
-// copy. It is compatible to both 16-byte aligned and unaligned addresses. If
-// data at the destination is not immediately accessed, using non-temporal
-// memcpy can save 1 DRAM load of the destination cacheline.
-constexpr size_t kCacheLineSize = ABSL_CACHELINE_SIZE;
-
-// If the objects overlap, the behavior is undefined. Uses regular memcpy
-// instead of non-temporal memcpy if the required CPU intrinsics are unavailable
-// at compile time.
-inline void *non_temporal_store_memcpy(void *__restrict dst,
-                                       const void *__restrict src, size_t len) {
-#if defined(__SSE3__) || defined(__aarch64__) || \
-    (defined(_MSC_VER) && defined(__AVX__))
-  // This implementation requires SSE3.
-  // MSVC cannot target SSE3 directly, but when MSVC targets AVX,
-  // SSE3 support is implied.
-  uint8_t *d = reinterpret_cast<uint8_t *>(dst);
-  const uint8_t *s = reinterpret_cast<const uint8_t *>(src);
-
-  // memcpy() the misaligned header. At the end of this if block, <d> is
-  // aligned to a 64-byte cacheline boundary or <len> == 0.
-  if (reinterpret_cast<uintptr_t>(d) & (kCacheLineSize - 1)) {
-    uintptr_t bytes_before_alignment_boundary =
-        kCacheLineSize -
-        (reinterpret_cast<uintptr_t>(d) & (kCacheLineSize - 1));
-    size_t header_len = (std::min)(bytes_before_alignment_boundary, len);
-    assert(bytes_before_alignment_boundary < kCacheLineSize);
-    memcpy(d, s, header_len);
-    d += header_len;
-    s += header_len;
-    len -= header_len;
-  }
-
-  if (len >= kCacheLineSize) {
-    _mm_sfence();
-    __m128i *dst_cacheline = reinterpret_cast<__m128i *>(d);
-    const __m128i *src_cacheline = reinterpret_cast<const __m128i *>(s);
-    constexpr int kOpsPerCacheLine = kCacheLineSize / sizeof(__m128i);
-    size_t loops = len / kCacheLineSize;
-
-    while (len >= kCacheLineSize) {
-      __m128i temp1, temp2, temp3, temp4;
-      temp1 = _mm_lddqu_si128(src_cacheline + 0);
-      temp2 = _mm_lddqu_si128(src_cacheline + 1);
-      temp3 = _mm_lddqu_si128(src_cacheline + 2);
-      temp4 = _mm_lddqu_si128(src_cacheline + 3);
-      _mm_stream_si128(dst_cacheline + 0, temp1);
-      _mm_stream_si128(dst_cacheline + 1, temp2);
-      _mm_stream_si128(dst_cacheline + 2, temp3);
-      _mm_stream_si128(dst_cacheline + 3, temp4);
-      src_cacheline += kOpsPerCacheLine;
-      dst_cacheline += kOpsPerCacheLine;
-      len -= kCacheLineSize;
-    }
-    d += loops * kCacheLineSize;
-    s += loops * kCacheLineSize;
-    _mm_sfence();
-  }
-
-  // memcpy the tail.
-  if (len) {
-    memcpy(d, s, len);
-  }
-  return dst;
-#else
-  // Fallback to regular memcpy.
-  return memcpy(dst, src, len);
-#endif  // __SSE3__ || __aarch64__ || (_MSC_VER && __AVX__)
-}
-
-// We try to force non_temporal_store_memcpy_avx to use AVX instructions
-// so that we can select it at runtime when AVX is available.
-// Clang on Windows has gnu::target but does not make AVX types like __m256i
-// available when trying to force specific functions to use AVX compiles.
-#if ABSL_HAVE_CPP_ATTRIBUTE(gnu::target) && !defined(_MSC_VER) && \
-    (defined(__x86_64__) || defined(__i386__))
-#define ABSL_INTERNAL_CAN_FORCE_AVX 1
-#endif
-
-// If the objects overlap, the behavior is undefined. Uses regular memcpy
-// instead of non-temporal memcpy if the required CPU intrinsics are unavailable
-// at compile time.
-#ifdef ABSL_INTERNAL_CAN_FORCE_AVX
-[[gnu::target("avx")]]
-#endif
-inline void *non_temporal_store_memcpy_avx(void *__restrict dst,
-                                           const void *__restrict src,
-                                           size_t len) {
-  // This function requires AVX. If possible we compile it with AVX even if the
-  // translation unit isn't built with AVX support. This works because we only
-  // select this implementation at runtime if the CPU supports AVX.
-  // MSVC AVX support implies SSE3 support.
-#if ((defined(__AVX__) || defined(ABSL_INTERNAL_CAN_FORCE_AVX)) && \
-     defined(__SSE3__)) ||                                         \
-    (defined(_MSC_VER) && defined(__AVX__))
-  uint8_t *d = reinterpret_cast<uint8_t *>(dst);
-  const uint8_t *s = reinterpret_cast<const uint8_t *>(src);
-
-  // memcpy() the misaligned header. At the end of this if block, <d> is
-  // aligned to a 64-byte cacheline boundary or <len> == 0.
-  if (reinterpret_cast<uintptr_t>(d) & (kCacheLineSize - 1)) {
-    uintptr_t bytes_before_alignment_boundary =
-        kCacheLineSize -
-        (reinterpret_cast<uintptr_t>(d) & (kCacheLineSize - 1));
-    size_t header_len = (std::min)(bytes_before_alignment_boundary, len);
-    assert(bytes_before_alignment_boundary < kCacheLineSize);
-    memcpy(d, s, header_len);
-    d += header_len;
-    s += header_len;
-    len -= header_len;
-  }
-
-  if (len >= kCacheLineSize) {
-    _mm_sfence();
-    __m256i *dst_cacheline = reinterpret_cast<__m256i *>(d);
-    const __m256i *src_cacheline = reinterpret_cast<const __m256i *>(s);
-    constexpr int kOpsPerCacheLine = kCacheLineSize / sizeof(__m256i);
-    size_t loops = len / kCacheLineSize;
-
-    while (len >= kCacheLineSize) {
-      __m256i temp1, temp2;
-      temp1 = _mm256_lddqu_si256(src_cacheline + 0);
-      temp2 = _mm256_lddqu_si256(src_cacheline + 1);
-      _mm256_stream_si256(dst_cacheline + 0, temp1);
-      _mm256_stream_si256(dst_cacheline + 1, temp2);
-      src_cacheline += kOpsPerCacheLine;
-      dst_cacheline += kOpsPerCacheLine;
-      len -= kCacheLineSize;
-    }
-    d += loops * kCacheLineSize;
-    s += loops * kCacheLineSize;
-    _mm_sfence();
-  }
-
-  // memcpy the tail.
-  if (len) {
-    memcpy(d, s, len);
-  }
-  return dst;
-#else
-  // Fallback to regular memcpy so that this function compiles.
-  return memcpy(dst, src, len);
-#endif
-}
-
-#undef ABSL_INTERNAL_CAN_FORCE_AVX
-
-}  // namespace crc_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CRC_INTERNAL_NON_TEMPORAL_MEMCPY_H_

package/deps/abseil-cpp/absl/crc/internal/non_temporal_memcpy_test.cc

@@ -1,90 +0,0 @@
-// Copyright 2022 The Abseil Authors
-//
-// 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 "absl/crc/internal/non_temporal_memcpy.h"
-
-#include <algorithm>
-#include <cstdint>
-#include <iostream>
-#include <vector>
-
-#include "gtest/gtest.h"
-
-namespace {
-
-struct TestParam {
-  size_t copy_size;
-  uint32_t src_offset;
-  uint32_t dst_offset;
-};
-
-class NonTemporalMemcpyTest : public testing::TestWithParam<TestParam> {
- protected:
-  void SetUp() override {
-    // Make buf_size multiple of 16 bytes.
-    size_t buf_size = ((std::max(GetParam().src_offset, GetParam().dst_offset) +
-                        GetParam().copy_size) +
-                       15) /
-                      16 * 16;
-    a_.resize(buf_size);
-    b_.resize(buf_size);
-    for (size_t i = 0; i < buf_size; i++) {
-      a_[i] = static_cast<uint8_t>(i % 256);
-      b_[i] = ~a_[i];
-    }
-  }
-
-  std::vector<uint8_t> a_, b_;
-};
-
-TEST_P(NonTemporalMemcpyTest, SSEEquality) {
-  uint8_t *src = a_.data() + GetParam().src_offset;
-  uint8_t *dst = b_.data() + GetParam().dst_offset;
-  absl::crc_internal::non_temporal_store_memcpy(dst, src, GetParam().copy_size);
-  for (size_t i = 0; i < GetParam().copy_size; i++) {
-    EXPECT_EQ(src[i], dst[i]);
-  }
-}
-
-#ifdef __AVX__
-TEST_P(NonTemporalMemcpyTest, AVXEquality) {
-  uint8_t* src = a_.data() + GetParam().src_offset;
-  uint8_t* dst = b_.data() + GetParam().dst_offset;
-
-  absl::crc_internal::non_temporal_store_memcpy_avx(dst, src,
-                                                    GetParam().copy_size);
-  for (size_t i = 0; i < GetParam().copy_size; i++) {
-    EXPECT_EQ(src[i], dst[i]);
-  }
-}
-#endif
-
-// 63B is smaller than one cacheline operation thus the non-temporal routine
-// will not be called.
-// 4352B is sufficient for testing 4092B data copy with room for offsets.
-constexpr TestParam params[] = {
-    {63, 0, 0},       {58, 5, 5},    {61, 2, 0},    {61, 0, 2},
-    {58, 5, 2},       {4096, 0, 0},  {4096, 0, 1},  {4096, 0, 2},
-    {4096, 0, 3},     {4096, 0, 4},  {4096, 0, 5},  {4096, 0, 6},
-    {4096, 0, 7},     {4096, 0, 8},  {4096, 0, 9},  {4096, 0, 10},
-    {4096, 0, 11},    {4096, 0, 12}, {4096, 0, 13}, {4096, 0, 14},
-    {4096, 0, 15},    {4096, 7, 7},  {4096, 3, 0},  {4096, 1, 0},
-    {4096, 9, 3},     {4096, 9, 11}, {8192, 0, 0},  {8192, 5, 2},
-    {1024768, 7, 11}, {1, 0, 0},     {1, 0, 1},     {1, 1, 0},
-    {1, 1, 1}};
-
-INSTANTIATE_TEST_SUITE_P(ParameterizedNonTemporalMemcpyTest,
-                         NonTemporalMemcpyTest, testing::ValuesIn(params));
-
-}  // namespace