mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-08-16 17:00:35 +03:00
AK: Introduce get_random_uniform()
This is arc4random_uniform(), but inside AK.
This commit is contained in:
parent
ad7cd05fc1
commit
069bf988ed
Notes:
sideshowbarker
2024-07-18 22:57:59 +09:00
Author: https://github.com/boricj Commit: https://github.com/SerenityOS/serenity/commit/069bf988ed9 Pull-request: https://github.com/SerenityOS/serenity/pull/7105
31
AK/Random.cpp
Normal file
31
AK/Random.cpp
Normal file
@ -0,0 +1,31 @@
|
||||
/*
|
||||
* Copyright (c) 2021, the SerenityOS developers.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#include <AK/Random.h>
|
||||
|
||||
namespace AK {
|
||||
|
||||
u32 get_random_uniform(u32 max_bounds)
|
||||
{
|
||||
// If we try to divide all 2**32 numbers into groups of "max_bounds" numbers, we may end up
|
||||
// with a group around 2**32-1 that is a bit too small. For this reason, the implementation
|
||||
// `arc4random() % max_bounds` would be insufficient. Here we compute the last number of the
|
||||
// last "full group". Note that if max_bounds is a divisor of UINT32_MAX,
|
||||
// then we end up with UINT32_MAX:
|
||||
const u32 max_usable = UINT32_MAX - (static_cast<u64>(UINT32_MAX) + 1) % max_bounds;
|
||||
auto random_value = get_random<u32>();
|
||||
for (int i = 0; i < 20 && random_value > max_usable; ++i) {
|
||||
// By chance we picked a value from the incomplete group. Note that this group has size at
|
||||
// most 2**31-1, so picking this group has a chance of less than 50%.
|
||||
// In practice, this means that for the worst possible input, there is still only a
|
||||
// once-in-a-million chance to get to iteration 20. In theory we should be able to loop
|
||||
// forever. Here we prefer marginally imperfect random numbers over weird runtime behavior.
|
||||
random_value = get_random<u32>();
|
||||
}
|
||||
return random_value % max_bounds;
|
||||
}
|
||||
|
||||
}
|
@ -41,7 +41,10 @@ inline T get_random()
|
||||
return t;
|
||||
}
|
||||
|
||||
u32 get_random_uniform(u32 max_bounds);
|
||||
|
||||
}
|
||||
|
||||
using AK::fill_with_random;
|
||||
using AK::get_random;
|
||||
using AK::get_random_uniform;
|
||||
|
@ -7,6 +7,7 @@
|
||||
#include <AK/Assertions.h>
|
||||
#include <AK/HashMap.h>
|
||||
#include <AK/Noncopyable.h>
|
||||
#include <AK/Random.h>
|
||||
#include <AK/StdLibExtras.h>
|
||||
#include <AK/Types.h>
|
||||
#include <AK/Utf8View.h>
|
||||
@ -1093,22 +1094,7 @@ void arc4random_buf(void* buffer, size_t buffer_size)
|
||||
|
||||
uint32_t arc4random_uniform(uint32_t max_bounds)
|
||||
{
|
||||
// If we try to divide all 2**32 numbers into groups of "max_bounds" numbers, we may end up
|
||||
// with a group around 2**32-1 that is a bit too small. For this reason, the implementation
|
||||
// `arc4random() % max_bounds` would be insufficient. Here we compute the last number of the
|
||||
// last "full group". Note that if max_bounds is a divisor of UINT32_MAX,
|
||||
// then we end up with UINT32_MAX:
|
||||
const uint32_t max_usable = UINT32_MAX - (static_cast<uint64_t>(UINT32_MAX) + 1) % max_bounds;
|
||||
uint32_t random_value = arc4random();
|
||||
for (int i = 0; i < 20 && random_value > max_usable; ++i) {
|
||||
// By chance we picked a value from the incomplete group. Note that this group has size at
|
||||
// most 2**31-1, so picking this group has a chance of less than 50%.
|
||||
// In practice, this means that for the worst possible input, there is still only a
|
||||
// once-in-a-million chance to get to iteration 20. In theory we should be able to loop
|
||||
// forever. Here we prefer marginally imperfect random numbers over weird runtime behavior.
|
||||
random_value = arc4random();
|
||||
}
|
||||
return random_value % max_bounds;
|
||||
return AK::get_random_uniform(max_bounds);
|
||||
}
|
||||
|
||||
char* realpath(const char* pathname, char* buffer)
|
||||
|
Loading…
Reference in New Issue
Block a user