225 lines
8.1 KiB
C++
225 lines
8.1 KiB
C++
// Copyright 2017 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.
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
// File: random.h
|
|
// -----------------------------------------------------------------------------
|
|
//
|
|
// This header defines the recommended Uniform Random Bit Generator (URBG)
|
|
// types for use within the Abseil Random library. These types are not
|
|
// suitable for security-related use-cases, but should suffice for most other
|
|
// uses of generating random values.
|
|
//
|
|
// The Abseil random library provides the following URBG types:
|
|
//
|
|
// * BitGen, a good general-purpose bit generator, optimized for generating
|
|
// random (but not cryptographically secure) values
|
|
// * InsecureBitGen, a slightly faster, though less random, bit generator, for
|
|
// cases where the existing BitGen is a drag on performance.
|
|
|
|
#ifndef ABSL_RANDOM_RANDOM_H_
|
|
#define ABSL_RANDOM_RANDOM_H_
|
|
|
|
#include <cstdint>
|
|
#include <random>
|
|
|
|
#include "absl/base/config.h"
|
|
#include "absl/random/distributions.h" // IWYU pragma: export
|
|
#include "absl/random/internal/nonsecure_base.h"
|
|
#include "absl/random/internal/pcg_engine.h"
|
|
#include "absl/random/internal/randen_engine.h"
|
|
#include "absl/random/seed_sequences.h" // IWYU pragma: export
|
|
|
|
namespace absl {
|
|
ABSL_NAMESPACE_BEGIN
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// absl::BitGen
|
|
// -----------------------------------------------------------------------------
|
|
//
|
|
// `absl::BitGen` is a general-purpose random bit generator for generating
|
|
// random values for use within the Abseil random library. Typically, you use a
|
|
// bit generator in combination with a distribution to provide random values.
|
|
//
|
|
// Example:
|
|
//
|
|
// // Create an absl::BitGen. There is no need to seed this bit generator.
|
|
// absl::BitGen gen;
|
|
//
|
|
// // Generate an integer value in the closed interval [1,6]
|
|
// int die_roll = absl::uniform_int_distribution<int>(1, 6)(gen);
|
|
//
|
|
// `absl::BitGen` is seeded by default with non-deterministic data to produce
|
|
// different sequences of random values across different instances, including
|
|
// different binary invocations. This behavior is different than the standard
|
|
// library bit generators, which use golden values as their seeds. Default
|
|
// construction intentionally provides no stability guarantees, to avoid
|
|
// accidental dependence on such a property.
|
|
//
|
|
// `absl::BitGen` may be constructed with an optional seed sequence type,
|
|
// conforming to [rand.req.seed_seq], which will be mixed with additional
|
|
// non-deterministic data as detailed below.
|
|
//
|
|
// Example:
|
|
//
|
|
// // Create an absl::BitGen using an std::seed_seq seed sequence
|
|
// std::seed_seq seq{1,2,3};
|
|
// absl::BitGen gen_with_seed(seq);
|
|
//
|
|
// // Generate an integer value in the closed interval [1,6]
|
|
// int die_roll2 = absl::uniform_int_distribution<int>(1, 6)(gen_with_seed);
|
|
//
|
|
// Constructing two `absl::BitGen`s with the same seed sequence in the same
|
|
// process will produce the same sequence of variates, but need not do so across
|
|
// multiple processes even if they're executing the same binary.
|
|
//
|
|
// `absl::BitGen` meets the requirements of the Uniform Random Bit Generator
|
|
// (URBG) concept as per the C++17 standard [rand.req.urng] though differs
|
|
// slightly with [rand.req.eng]. Like its standard library equivalents (e.g.
|
|
// `std::mersenne_twister_engine`) `absl::BitGen` is not cryptographically
|
|
// secure.
|
|
//
|
|
// This type has been optimized to perform better than Mersenne Twister
|
|
// (https://en.wikipedia.org/wiki/Mersenne_Twister) and many other complex URBG
|
|
// types on modern x86, ARM, and PPC architectures.
|
|
//
|
|
// This type is thread-compatible, but not thread-safe.
|
|
class BitGen : private random_internal::NonsecureURBGBase<
|
|
random_internal::randen_engine<uint64_t>> {
|
|
using Base = random_internal::NonsecureURBGBase<
|
|
random_internal::randen_engine<uint64_t>>;
|
|
|
|
public:
|
|
using result_type = typename Base::result_type;
|
|
|
|
// BitGen()
|
|
// BitGen(SeedSequence seed_seq)
|
|
//
|
|
// Copy disallowed.
|
|
// Move allowed.
|
|
using Base::Base;
|
|
using Base::operator=;
|
|
|
|
// BitGen::min()
|
|
//
|
|
// Returns the smallest possible value from this bit generator.
|
|
using Base::min;
|
|
|
|
// BitGen::max()
|
|
//
|
|
// Returns the largest possible value from this bit generator.
|
|
using Base::max;
|
|
|
|
// BitGen::discard(num)
|
|
//
|
|
// Advances the internal state of this bit generator by `num` times, and
|
|
// discards the intermediate results.
|
|
using Base::discard;
|
|
|
|
// BitGen::operator()()
|
|
//
|
|
// Invoke the URBG, returning a generated value.
|
|
using Base::operator();
|
|
|
|
using Base::operator==;
|
|
using Base::operator!=;
|
|
};
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// absl::InsecureBitGen
|
|
// -----------------------------------------------------------------------------
|
|
//
|
|
// `absl::InsecureBitGen` is an efficient random bit generator for generating
|
|
// random values, recommended only for performance-sensitive use cases where
|
|
// `absl::BitGen` is not satisfactory when compute-bounded by bit generation
|
|
// costs.
|
|
//
|
|
// Example:
|
|
//
|
|
// // Create an absl::InsecureBitGen
|
|
// absl::InsecureBitGen gen;
|
|
// for (size_t i = 0; i < 1000000; i++) {
|
|
//
|
|
// // Generate a bunch of random values from some complex distribution
|
|
// auto my_rnd = some_distribution(gen, 1, 1000);
|
|
// }
|
|
//
|
|
// Like `absl::BitGen`, `absl::InsecureBitGen` is seeded by default with
|
|
// non-deterministic data to produce different sequences of random values across
|
|
// different instances, including different binary invocations. (This behavior
|
|
// is different than the standard library bit generators, which use golden
|
|
// values as their seeds.)
|
|
//
|
|
// `absl::InsecureBitGen` may be constructed with an optional seed sequence
|
|
// type, conforming to [rand.req.seed_seq], which will be mixed with additional
|
|
// non-deterministic data, as detailed in the `absl::BitGen` comment.
|
|
//
|
|
// `absl::InsecureBitGen` meets the requirements of the Uniform Random Bit
|
|
// Generator (URBG) concept as per the C++17 standard [rand.req.urng] though
|
|
// its implementation differs slightly with [rand.req.eng]. Like its standard
|
|
// library equivalents (e.g. `std::mersenne_twister_engine`)
|
|
// `absl::InsecureBitGen` is not cryptographically secure.
|
|
//
|
|
// Prefer `absl::BitGen` over `absl::InsecureBitGen` as the general type is
|
|
// often fast enough for the vast majority of applications. However, it is
|
|
// reasonable to use `absl::InsecureBitGen` in tests or when using a URBG
|
|
// in small isolated tasks such as in `std::shuffle`.
|
|
//
|
|
// This type is thread-compatible, but not thread-safe.
|
|
class InsecureBitGen : private random_internal::NonsecureURBGBase<
|
|
random_internal::pcg64_2018_engine> {
|
|
using Base =
|
|
random_internal::NonsecureURBGBase<random_internal::pcg64_2018_engine>;
|
|
|
|
public:
|
|
using result_type = typename Base::result_type;
|
|
|
|
// InsecureBitGen()
|
|
// InsecureBitGen(SeedSequence seed_seq)
|
|
//
|
|
// Copy disallowed.
|
|
// Move allowed.
|
|
using Base::Base;
|
|
using Base::operator=;
|
|
|
|
// InsecureBitGen::min()
|
|
//
|
|
// Returns the smallest possible value from this bit generator.
|
|
using Base::min;
|
|
|
|
// InsecureBitGen::max()
|
|
//
|
|
// Returns the largest possible value from this bit generator.
|
|
using Base::max;
|
|
|
|
// InsecureBitGen::discard(num)
|
|
//
|
|
// Advances the internal state of this bit generator by `num` times, and
|
|
// discards the intermediate results.
|
|
using Base::discard;
|
|
|
|
// InsecureBitGen::operator()()
|
|
//
|
|
// Invoke the URBG, returning a generated value.
|
|
using Base::operator();
|
|
|
|
using Base::operator==;
|
|
using Base::operator!=;
|
|
};
|
|
|
|
ABSL_NAMESPACE_END
|
|
} // namespace absl
|
|
|
|
#endif // ABSL_RANDOM_RANDOM_H_
|