Skip to content

Fix integer fills and bytes() for BRNGs without viRngUniformBits support #175

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
vlad-perevezentsev wants to merge 11 commits into
base: master
Choose a base branch
from
Open

Fix integer fills and bytes() for BRNGs without viRngUniformBits support #175

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
e3fdbe8
Support all BRNGs in scalar full-range randint via viRngUniform fallback
vlad-perevezentsev Sep 8, 2026
78e02ed
Unskip scalar full-range randint test for all BRNGs
vlad-perevezentsev Sep 8, 2026
684cf03
Support all BRNGs in legacy long randint fills via viRngUniform fallback
vlad-perevezentsev Sep 8, 2026
37dc783
Add test_legacy_long_path_full_range
vlad-perevezentsev Sep 8, 2026
c5c561b
Merge remote-tracking branch 'origin/master' into fix-scalar-full-ran…
vlad-perevezentsev Sep 17, 2026
fb9aa86
Fix 64-bit integer fills of 2**30 elements or more
vlad-perevezentsev Sep 17, 2026
6ad2551
Support all BRNGs in bytes via viRngUniform fallback
vlad-perevezentsev Sep 17, 2026
9c64850
Add test_bytes_all_brngs to test_random.py
vlad-perevezentsev Sep 17, 2026
5c87c38
Add gh-175 to changelog
vlad-perevezentsev Sep 17, 2026
bab16e8
Remove randint_untyped from the legacy long-path test
vlad-perevezentsev Sep 17, 2026
b89c330
Merge branch 'master' into fix-scalar-full-range-brng
ndgrigorian Sep 24, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions CHANGELOG.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,6 +26,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
* Fixed `multinomial` under-filling large outputs by decrementing its chunk counter by elements instead of draws [gh-172](https://github.com/IntelPython/mkl_random/pull/172)
* Fixed a memory leak in `set_state`, which leaked the previous MKL stream on every call [gh-159](https://github.com/IntelPython/mkl_random/pull/159)
* Fixed a memory leak in `logseries`, which leaked a temporary buffer on every call [gh-159](https://github.com/IntelPython/mkl_random/pull/159)
* Fixed `randint` with scalar bounds above `INT_MAX`, `tomaxint` and `bytes` returning uninitialized data for `WH`, `MCG31`, `R250` and `MRG32K3A`, which lack `viRngUniformBits` support [gh-175](https://github.com/IntelPython/mkl_random/pull/175)
* Fixed 64-bit integer generation returning zeros or crashing with `PHILOX4X32X10` and `ARS5` for requests of `2**30` elements or more [gh-175](https://github.com/IntelPython/mkl_random/pull/175)

### Removed
* Removed the `python-gil` constraint from the conda recipes, which pinned `mkl_random` to GIL-enabled Python 3.14 builds [gh-159](https://github.com/IntelPython/mkl_random/pull/159)
Expand Down
218 changes: 105 additions & 113 deletions mkl_random/src/mkl_distributions.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1620,6 +1620,103 @@ void irk_discrete_uniform_vec(irk_state *state,
assert(err == VSL_STATUS_OK);
}

/*
* Bulk source of raw uniform words for the bounded-integer
* routines below, overloaded on the word type (32/64-bit). BRNGs that lack
* viRngUniformBits fall back to assembling words from viRngUniform.
*/
static inline void
irk_uniform_bits_vec(irk_state *state, npy_intp len, npy_uint32 *buf)
{
int err = 0;
npy_intp i = 0;

while (len > 0) {
MKL_INT c = (len > MKL_INT_MAX) ? (MKL_INT)MKL_INT_MAX : (MKL_INT)len;
err = viRngUniformBits32(VSL_RNG_METHOD_UNIFORMBITS32_STD,
state->stream, c, (unsigned int *)buf);
if (err == VSL_RNG_ERROR_BRNG_NOT_SUPPORTED) {
/* viRngUniformBits32 unsupported for WH/MCG31/R250/MRG32K3A;
* build each word from two 16-bit viRngUniform halves */
npy_intp total = 2 * (npy_intp)c, rem = total, off = 0;
int *tmp = (int *)mkl_malloc(total * sizeof(int), 64);
Comment on lines +1641 to +1642

@ndgrigorian ndgrigorian Sep 24, 2026

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This buffer is two times the size of the original length, so we end up spending a potentially huge amount of memory here, and we have no fallback for the case where the allocation fails either.

We could instead have a buffer that we reuse that's smaller and fill in chunks

assert(tmp != nullptr);
/* one call unless the count exceeds MKL_INT */
while (rem > 0) {
MKL_INT cc =
(rem > MKL_INT_MAX) ? (MKL_INT)MKL_INT_MAX : (MKL_INT)rem;
err = viRngUniform(VSL_RNG_METHOD_UNIFORM_STD, state->stream,
cc, tmp + off, 0, 65536);
assert(err == VSL_STATUS_OK);
off += cc;
rem -= cc;
}
for (i = 0; i < c; ++i)
buf[i] = ((npy_uint32)tmp[2 * i]) |
(((npy_uint32)tmp[2 * i + 1]) << 16);
mkl_free(tmp);
}
else {
assert(err == VSL_STATUS_OK);
}
buf += c;
len -= c;
}
}

static inline void
irk_uniform_bits_vec(irk_state *state, npy_intp len, npy_uint64 *buf)
{
int err = 0;
npy_intp i = 0;
/* viRngUniformBits64 counts 32-bit words, so its count must fit half of
* MKL_INT; larger requests under-fill the buffer or crash */
const npy_intp bits64_max = MKL_INT_MAX / 2;

while (len > 0) {
MKL_INT c = (len > bits64_max) ? (MKL_INT)bits64_max : (MKL_INT)len;
err = viRngUniformBits64(VSL_RNG_METHOD_UNIFORMBITS64_STD,
state->stream, c, (unsigned MKL_INT64 *)buf);
if (err == VSL_RNG_ERROR_BRNG_NOT_SUPPORTED) {
/* viRngUniformBits64 unsupported for WH/MCG31/R250/MRG32K3A;
* build each word from four 16-bit viRngUniform halves */
npy_intp total = 4 * (npy_intp)c, rem = total, off = 0;
int *tmp = (int *)mkl_malloc(total * sizeof(int), 64);

@ndgrigorian ndgrigorian Sep 24, 2026

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Same point here

assert(tmp != nullptr);
/* one call unless the count exceeds MKL_INT */
while (rem > 0) {
MKL_INT cc =
(rem > MKL_INT_MAX) ? (MKL_INT)MKL_INT_MAX : (MKL_INT)rem;
err = viRngUniform(VSL_RNG_METHOD_UNIFORM_STD, state->stream,
cc, tmp + off, 0, 65536);
assert(err == VSL_STATUS_OK);
off += cc;
rem -= cc;
}
for (i = 0; i < c; ++i)
buf[i] = ((npy_uint64)(npy_uint32)tmp[4 * i]) |
(((npy_uint64)(npy_uint32)tmp[4 * i + 1]) << 16) |
(((npy_uint64)(npy_uint32)tmp[4 * i + 2]) << 32) |
(((npy_uint64)(npy_uint32)tmp[4 * i + 3]) << 48);
mkl_free(tmp);
}
else {
assert(err == VSL_STATUS_OK);
}
buf += c;
len -= c;
}
}

/* C-linkage entry point: other files cannot call the overloads above. */
void irk_uniform_bits32_vec(irk_state *state, npy_intp len, npy_uint32 *res)
{
if (len < 1)
return;

irk_uniform_bits_vec(state, len, res);
}

void irk_discrete_uniform_long_vec(irk_state *state,
npy_intp len,
long *res,
Expand Down Expand Up @@ -1685,9 +1782,7 @@ void irk_discrete_uniform_long_vec(irk_state *state,
while (n_accepted < len) {
int k, batchSize = len - n_accepted;

err = viRngUniformBits64(VSL_RNG_METHOD_UNIFORM_STD, state->stream,
batchSize, (unsigned MKL_INT64 *)buf);
assert(err == VSL_STATUS_OK);
irk_uniform_bits_vec(state, batchSize, (npy_uint64 *)buf);

for (k = 0; k < batchSize; ++k) {
unsigned long value = buf[k] & mask;
Expand All @@ -1703,8 +1798,6 @@ void irk_discrete_uniform_long_vec(irk_state *state,

void irk_ulong_vec(irk_state *state, npy_intp len, unsigned long *res)
{
int err = 0;

if (len < 1)
return;

Expand All @@ -1716,14 +1809,10 @@ void irk_ulong_vec(irk_state *state, npy_intp len, unsigned long *res)
}

#if ULONG_MAX <= 0xffffffffUL
err = viRngUniformBits32(VSL_RNG_METHOD_UNIFORMBITS32_STD, state->stream,
len, (unsigned int *)res);
irk_uniform_bits_vec(state, len, (npy_uint32 *)res);
#else
err = viRngUniformBits64(VSL_RNG_METHOD_UNIFORMBITS64_STD, state->stream,
len, (unsigned MKL_INT64 *)res);
irk_uniform_bits_vec(state, len, (npy_uint64 *)res);
#endif

assert(err == VSL_STATUS_OK);
}

void irk_long_vec(irk_state *state, npy_intp len, long *res)
Expand Down Expand Up @@ -1844,9 +1933,7 @@ void irk_rand_uint32_vec(irk_state *state,

/* optimization for lo = 0 and hi = 2**32-1 */
if (!(lo || ~hi)) {
err = viRngUniformBits32(VSL_RNG_METHOD_UNIFORMBITS32_STD,
state->stream, len, (unsigned int *)res);
assert(err == VSL_STATUS_OK);
irk_uniform_bits_vec(state, len, res);

return;
}
Expand Down Expand Up @@ -1935,9 +2022,7 @@ void irk_rand_uint64_vec(irk_state *state,

/* optimization for lo = 0 and hi = 2**64-1 */
if (!(lo || ~hi)) {
err = viRngUniformBits64(VSL_RNG_METHOD_UNIFORMBITS64_STD,
state->stream, len, (unsigned MKL_INT64 *)res);
assert(err == VSL_STATUS_OK);
irk_uniform_bits_vec(state, len, res);

return;
}
Expand Down Expand Up @@ -1983,10 +2068,7 @@ void irk_rand_uint64_vec(irk_state *state,
if (mask == rng) {
/* rng + 1 is a power of two, so masking alone confines every draw
* to [0, rng] and nothing is rejected. Fill res directly. */
err = viRngUniformBits64(VSL_RNG_METHOD_UNIFORMBITS64_STD,
state->stream, len,
(unsigned MKL_INT64 *)res);
assert(err == VSL_STATUS_OK);
irk_uniform_bits_vec(state, len, res);

DIST_PRAGMA_VECTOR
for (i = 0; i < len; ++i)
Expand All @@ -1997,9 +2079,7 @@ void irk_rand_uint64_vec(irk_state *state,

/* Draw into res and compact in place; n_accepted never runs ahead of i,
* so the store cannot clobber an unread value. Acceptance is > 1/2. */
err = viRngUniformBits64(VSL_RNG_METHOD_UNIFORMBITS64_STD,
state->stream, len, (unsigned MKL_INT64 *)res);
assert(err == VSL_STATUS_OK);
irk_uniform_bits_vec(state, len, res);

for (i = 0; i < len; ++i) {
npy_uint64 value = res[i] & mask;
Expand All @@ -2017,10 +2097,7 @@ void irk_rand_uint64_vec(irk_state *state,
npy_intp k = 0;
npy_intp batchSize = len - n_accepted;

err = viRngUniformBits64(VSL_RNG_METHOD_UNIFORMBITS64_STD,
state->stream, batchSize,
(unsigned MKL_INT64 *)buf);
assert(err == VSL_STATUS_OK);
irk_uniform_bits_vec(state, batchSize, buf);

for (k = 0; k < batchSize; ++k) {
npy_uint64 value = buf[k] & mask;
Expand Down Expand Up @@ -2056,91 +2133,6 @@ void irk_rand_int64_vec(irk_state *state,
res[i] = res[i] + lo;
}

/*
* Bulk source of raw uniform words for the broadcasted bounded-integer
* routines below, overloaded on the word type (32/64-bit). BRNGs that lack
* viRngUniformBits fall back to assembling words from viRngUniform.
*/
static inline void
irk_uniform_bits_vec(irk_state *state, npy_intp len, npy_uint32 *buf)
{
int err = 0;
npy_intp i = 0;

while (len > 0) {
MKL_INT c = (len > MKL_INT_MAX) ? (MKL_INT)MKL_INT_MAX : (MKL_INT)len;
err = viRngUniformBits32(VSL_RNG_METHOD_UNIFORMBITS32_STD,
state->stream, c, (unsigned int *)buf);
if (err == VSL_RNG_ERROR_BRNG_NOT_SUPPORTED) {
/* viRngUniformBits32 unsupported for WH/MCG31/R250/MRG32K3A;
* build each word from two 16-bit viRngUniform halves */
npy_intp total = 2 * (npy_intp)c, rem = total, off = 0;
int *tmp = (int *)mkl_malloc(total * sizeof(int), 64);
assert(tmp != nullptr);
/* one call unless the count exceeds MKL_INT */
while (rem > 0) {
MKL_INT cc =
(rem > MKL_INT_MAX) ? (MKL_INT)MKL_INT_MAX : (MKL_INT)rem;
err = viRngUniform(VSL_RNG_METHOD_UNIFORM_STD, state->stream,
cc, tmp + off, 0, 65536);
assert(err == VSL_STATUS_OK);
off += cc;
rem -= cc;
}
for (i = 0; i < c; ++i)
buf[i] = ((npy_uint32)tmp[2 * i]) |
(((npy_uint32)tmp[2 * i + 1]) << 16);
mkl_free(tmp);
}
else {
assert(err == VSL_STATUS_OK);
}
buf += c;
len -= c;
}
}

static inline void
irk_uniform_bits_vec(irk_state *state, npy_intp len, npy_uint64 *buf)
{
int err = 0;
npy_intp i = 0;

while (len > 0) {
MKL_INT c = (len > MKL_INT_MAX) ? (MKL_INT)MKL_INT_MAX : (MKL_INT)len;
err = viRngUniformBits64(VSL_RNG_METHOD_UNIFORMBITS64_STD,
state->stream, c, (unsigned MKL_INT64 *)buf);
if (err == VSL_RNG_ERROR_BRNG_NOT_SUPPORTED) {
/* viRngUniformBits64 unsupported for WH/MCG31/R250/MRG32K3A;
* build each word from four 16-bit viRngUniform halves */
npy_intp total = 4 * (npy_intp)c, rem = total, off = 0;
int *tmp = (int *)mkl_malloc(total * sizeof(int), 64);
assert(tmp != nullptr);
/* one call unless the count exceeds MKL_INT */
while (rem > 0) {
MKL_INT cc =
(rem > MKL_INT_MAX) ? (MKL_INT)MKL_INT_MAX : (MKL_INT)rem;
err = viRngUniform(VSL_RNG_METHOD_UNIFORM_STD, state->stream,
cc, tmp + off, 0, 65536);
assert(err == VSL_STATUS_OK);
off += cc;
rem -= cc;
}
for (i = 0; i < c; ++i)
buf[i] = ((npy_uint64)(npy_uint32)tmp[4 * i]) |
(((npy_uint64)(npy_uint32)tmp[4 * i + 1]) << 16) |
(((npy_uint64)(npy_uint32)tmp[4 * i + 2]) << 32) |
(((npy_uint64)(npy_uint32)tmp[4 * i + 3]) << 48);
mkl_free(tmp);
}
else {
assert(err == VSL_STATUS_OK);
}
buf += c;
len -= c;
}
}

/* mulhi for Lemire (word * s): top 32 bits of the product, low to *lo. */
static inline npy_uint32 irk_mulhi(npy_uint32 a, npy_uint32 b, npy_uint32 *lo)
{
Expand Down
3 changes: 3 additions & 0 deletions mkl_random/src/mkl_distributions.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -246,6 +246,9 @@ extern "C"
int *res,
const double theta);

extern void
irk_uniform_bits32_vec(irk_state *state, npy_intp len, npy_uint32 *res);

extern void irk_discrete_uniform_vec(irk_state *state,
npy_intp len,
int *res,
Expand Down
22 changes: 6 additions & 16 deletions mkl_random/src/randomkit.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -83,6 +83,7 @@
#endif

#include "randomkit.h"
#include "mkl_distributions.h"

#ifndef RK_DEV_URANDOM
#define RK_DEV_URANDOM "/dev/urandom"
Expand Down Expand Up @@ -362,22 +363,15 @@ static unsigned long irk_hash(unsigned long key)
return key;
}

void irk_random_vec(irk_state *state, const int len, unsigned int *res)
{
viRngUniformBits(VSL_RNG_METHOD_UNIFORMBITS_STD, state->stream, len, res);
}

void irk_fill(void *buffer, size_t size, irk_state *state)
{
unsigned int r;
npy_uint32 r;
unsigned char *buf = reinterpret_cast<unsigned char *>(buffer);
int err, len;
npy_intp len;

/* len = size / 4 */
len = (size >> 2);
err = viRngUniformBits32(VSL_RNG_METHOD_UNIFORMBITS32_STD, state->stream,
len, (unsigned int *)buf);
assert(err == VSL_STATUS_OK);
len = (npy_intp)(size >> 2);
irk_uniform_bits32_vec(state, len, (npy_uint32 *)buf);

/* size = size % 4 */
size &= 0x03;
Expand All @@ -386,15 +380,11 @@ void irk_fill(void *buffer, size_t size, irk_state *state)
}

buf += (len << 2);
err = viRngUniformBits32(VSL_RNG_METHOD_UNIFORMBITS32_STD, state->stream, 1,
&r);
assert(err == VSL_STATUS_OK);
irk_uniform_bits32_vec(state, 1, &r);

for (; size; r >>= 8, size--) {
*(buf++) = (unsigned char)(r & 0xFF);
}
if (err)
printf("irk_fill: error encountered when calling Intel(R) MKL \n");
}

irk_error irk_devfill(void *buffer, size_t size, int strong)
Expand Down
Loading
Loading