YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.

// This source code is licensed under the BSD-style license found in the

// LICENSE file in the root directory of this source tree. An additional grant

// of patent rights can be found in the PATENTS file in the same directory.

//

// The following only applies to changes made to this file as part of YugaByte development.

//

// Portions Copyright (c) YugaByte, Inc.

//

// 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 "yb/rocksdb/util/dynamic_bloom.h"

#include "yb/rocksdb/util/allocator.h"

#include "yb/rocksdb/util/hash.h"

namespace rocksdb {

namespace {

uint32_t GetTotalBitsForLocality(uint32_t total_bits) {

  uint32_t num_blocks =

      (total_bits + CACHE_LINE_SIZE * 8 - 1) / (CACHE_LINE_SIZE * 8);

  // Make num_blocks an odd number to make sure more bits are involved

  // when determining which block.

  if (num_blocks % 2 == 0) {

    num_blocks++;

  }

  return num_blocks * (CACHE_LINE_SIZE * 8);

}

} // namespace

DynamicBloom::DynamicBloom(Allocator* allocator, uint32_t total_bits,

                           uint32_t locality, uint32_t num_probes,

                           uint32_t (*hash_func)(const Slice& key),

                           size_t huge_page_tlb_size,

                           Logger* logger)

    : DynamicBloom(num_probes, hash_func) {

  SetTotalBits(allocator, total_bits, locality, huge_page_tlb_size, logger);

}

Unexecuted instantiation: _ZN7rocksdb12DynamicBloomC2EPNS_9AllocatorEjjjPFjRKN2yb5SliceEEmPNS_6LoggerE

_ZN7rocksdb12DynamicBloomC1EPNS_9AllocatorEjjjPFjRKN2yb5SliceEEmPNS_6LoggerE

Line

Count

Source

50

129

    : DynamicBloom(num_probes, hash_func) {

51

129

  SetTotalBits(allocator, total_bits, locality, huge_page_tlb_size, logger);

52

129

}

DynamicBloom::DynamicBloom(uint32_t num_probes,

                           uint32_t (*hash_func)(const Slice& key))

    : kTotalBits(0),

      kNumBlocks(0),

      kNumProbes(num_probes),

      hash_func_(hash_func == nullptr ? &BloomHash : hash_func) {}

void DynamicBloom::SetRawData(unsigned char* raw_data, uint32_t total_bits,

                              uint32_t num_blocks) {

  data_ = reinterpret_cast<std::atomic<uint8_t>*>(raw_data);

  kTotalBits = total_bits;

  kNumBlocks = num_blocks;

}

void DynamicBloom::SetTotalBits(Allocator* allocator,

                                uint32_t total_bits, uint32_t locality,

                                size_t huge_page_tlb_size,

                                Logger* logger) {

  kTotalBits = (locality > 0) ? GetTotalBitsForLocality(total_bits)

                              : (total_bits + 7) / 8 * 8;

  kNumBlocks = (locality > 0) ? (kTotalBits / (CACHE_LINE_SIZE * 8)) : 0;

  assert(kNumBlocks > 0 || kTotalBits > 0);

  assert(kNumProbes > 0);

  uint32_t sz = kTotalBits / 8;

  if (kNumBlocks > 0) {

    sz += CACHE_LINE_SIZE - 1;

  }

  assert(allocator);

  char* raw = allocator->AllocateAligned(sz, huge_page_tlb_size, logger);

  memset(raw, 0, sz);

  auto cache_line_offset = reinterpret_cast<uintptr_t>(raw) % CACHE_LINE_SIZE;

  if (kNumBlocks > 0 && cache_line_offset > 0) {

    raw += CACHE_LINE_SIZE - cache_line_offset;

  }

  data_ = reinterpret_cast<std::atomic<uint8_t>*>(raw);

}

}  // namespace rocksdb