mirror of
https://github.com/facebook/rocksdb.git
synced 2024-11-29 00:34:03 +00:00
ad5325a736
Summary: * New public header unique_id.h and function GetUniqueIdFromTableProperties which computes a universally unique identifier based on table properties of table files from recent RocksDB versions. * Generation of DB session IDs is refactored so that they are guaranteed unique in the lifetime of a process running RocksDB. (SemiStructuredUniqueIdGen, new test included.) Along with file numbers, this enables SST unique IDs to be guaranteed unique among SSTs generated in a single process, and "better than random" between processes. See https://github.com/pdillinger/unique_id * In addition to public API producing 'external' unique IDs, there is a function for producing 'internal' unique IDs, with functions for converting between the two. In short, the external ID is "safe" for things people might do with it, and the internal ID enables more "power user" features for the future. Specifically, the external ID goes through a hashing layer so that any subset of bits in the external ID can be used as a hash of the full ID, while also preserving uniqueness guarantees in the first 128 bits (bijective both on first 128 bits and on full 192 bits). Intended follow-up: * Use the internal unique IDs in cache keys. (Avoid conflicts with https://github.com/facebook/rocksdb/issues/8912) (The file offset can be XORed into the third 64-bit value of the unique ID.) * Publish the external unique IDs in FileStorageInfo (https://github.com/facebook/rocksdb/issues/8968) Pull Request resolved: https://github.com/facebook/rocksdb/pull/8990 Test Plan: Unit tests added, and checking of unique ids in stress test. NOTE in stress test we do not generate nearly enough files to thoroughly stress uniqueness, but the test trims off pieces of the ID to check for uniqueness so that we can infer (with some assumptions) stronger properties in the aggregate. Reviewed By: zhichao-cao, mrambacher Differential Revision: D31582865 Pulled By: pdillinger fbshipit-source-id: 1f620c4c86af9abe2a8d177b9ccf2ad2b9f48243
70 lines
2.8 KiB
C++
70 lines
2.8 KiB
C++
// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
// (found in the LICENSE.Apache file in the root directory).
|
|
|
|
// This file is for functions that generate unique identifiers by
|
|
// (at least in part) by extracting novel entropy or sources of uniqueness
|
|
// from the execution environment. (By contrast, random.h is for algorithmic
|
|
// pseudorandomness.)
|
|
//
|
|
// These functions could eventually migrate to public APIs, such as in Env.
|
|
|
|
#pragma once
|
|
|
|
#include <atomic>
|
|
#include <cstdint>
|
|
|
|
#include "rocksdb/rocksdb_namespace.h"
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
|
|
// Generates a new 128-bit identifier that is universally unique
|
|
// (with high probability) for each call. The result is split into
|
|
// two 64-bit pieces. This function has NOT been validated for use in
|
|
// cryptography.
|
|
//
|
|
// This is used in generating DB session IDs and by Env::GenerateUniqueId
|
|
// (used for DB IDENTITY) if the platform does not provide a generator of
|
|
// RFC 4122 UUIDs or fails somehow. (Set exclude_port_uuid=true if this
|
|
// function is used as a fallback for GenerateRfcUuid, because no need
|
|
// trying it again.)
|
|
void GenerateRawUniqueId(uint64_t* a, uint64_t* b,
|
|
bool exclude_port_uuid = false);
|
|
|
|
#ifndef NDEBUG
|
|
// A version of above with options for challenge testing
|
|
void TEST_GenerateRawUniqueId(uint64_t* a, uint64_t* b, bool exclude_port_uuid,
|
|
bool exclude_env_details,
|
|
bool exclude_random_device);
|
|
#endif
|
|
|
|
// Generates globally unique ids with lower probability of any collisions
|
|
// vs. each unique id being independently random (GenerateRawUniqueId).
|
|
// We call this "semi-structured" because between different
|
|
// SemiStructuredUniqueIdGen objects, the IDs are separated by random
|
|
// intervals (unstructured), but within a single SemiStructuredUniqueIdGen
|
|
// object, the generated IDs are trivially related (structured). See
|
|
// https://github.com/pdillinger/unique_id for how this improves probability
|
|
// of no collision. In short, if we have n SemiStructuredUniqueIdGen
|
|
// objects each generating m IDs, the first collision is expected at
|
|
// around n = sqrt(2^128 / m), equivalently n * sqrt(m) = 2^64,
|
|
// rather than n * m = 2^64 for fully random IDs.
|
|
class SemiStructuredUniqueIdGen {
|
|
public:
|
|
// Initializes with random starting state (from GenerateRawUniqueId)
|
|
SemiStructuredUniqueIdGen();
|
|
|
|
// Assuming no fork(), `lower` is guaranteed unique from one call
|
|
// to the next (thread safe).
|
|
void GenerateNext(uint64_t* upper, uint64_t* lower);
|
|
|
|
private:
|
|
uint64_t base_upper_;
|
|
uint64_t base_lower_;
|
|
std::atomic<uint64_t> counter_;
|
|
int64_t saved_process_id_;
|
|
};
|
|
|
|
} // namespace ROCKSDB_NAMESPACE
|