commit e860a7e620d19eab4ae419312f2dc0655511953b
parent 1cfc01ff3b8b1dd26f98fa268fba021b1f9370a4
Author: Vincent Forest <vincent.forest@meso-star.com>
Date: Wed, 2 Dec 2020 11:19:22 +0100
Merge branch 'feature_rw_cstr' into develop
Diffstat:
| M | src/ssp.h | | | 44 | +++++++++++++++++++++++++++++++++++--------- |
| M | src/ssp_rng.c | | | 125 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------- |
| M | src/ssp_rng_proxy.c | | | 368 | ++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------- |
| M | src/test_ssp_rng.c | | | 38 | ++++++++++++++++++++++++++++++++++++-- |
| M | src/test_ssp_rng_proxy.c | | | 206 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------ |
5 files changed, 596 insertions(+), 185 deletions(-)
diff --git a/src/ssp.h b/src/ssp.h
@@ -76,7 +76,9 @@ struct ssp_rng_type {
uint64_t (*get)(void* state);
res_T (*discard)(void* state, uint64_t n);
res_T (*read)(void* state, FILE* file);
+ res_T (*read_cstr)(void* state, const char* cstr);
res_T (*write)(const void* state, FILE* file);
+ res_T (*write_cstr)(const void* state, char* buf, const size_t sz, size_t* len);
double (*entropy)(const void* state);
uint64_t min;
@@ -95,13 +97,29 @@ ssp_rng_type_eq(const struct ssp_rng_type* t0, const struct ssp_rng_type* t1)
&& t0->get == t1->get
&& t0->discard == t1->discard
&& t0->read == t1->read
+ && t0->read_cstr == t1->read_cstr
&& t0->write == t1->write
+ && t0->write_cstr == t1->write_cstr
&& t0->entropy == t1->entropy
&& t0->min == t1->min
&& t0->max == t1->max
- && t0->sizeof_state == t1->sizeof_state;
+ && t0->sizeof_state == t1->sizeof_state
+ && t0->alignof_state == t1->alignof_state;
}
+/* Arguments of the ssp_rng_proxy_create2 function */
+struct ssp_rng_proxy_create2_args {
+ const struct ssp_rng* rng; /* Original RNG state. May be NULL*/
+ const struct ssp_rng_type* type; /* Type of the RN if 'rng' is NULL */
+ size_t sequence_offset; /* #RNs before the 1st valid sequence */
+ size_t sequence_size; /* #RNs in a sequence */
+ size_t sequence_pitch; /* #RNs between sequences. Must be >= sequence_size */
+ size_t nbuckets; /* #buckets of continuous RNs in a sequence */
+};
+#define SSP_RNG_PROXY_CREATE2_ARGS_NULL__ {NULL, NULL, 0, 0, 0, 0}
+static const struct ssp_rng_proxy_create2_args SSP_RNG_PROXY_CREATE2_ARGS_NULL =
+ SSP_RNG_PROXY_CREATE2_ARGS_NULL__;
+
BEGIN_DECLS
/* David Jones's Keep It Simple Stupid builtin PRNG type. Suitable for fast
@@ -202,15 +220,27 @@ ssp_rng_max
(struct ssp_rng* rng);
SSP_API res_T
-ssp_rng_write
- (const struct ssp_rng* rng,
+ssp_rng_read
+ (struct ssp_rng* rng,
FILE* stream);
SSP_API res_T
-ssp_rng_read
+ssp_rng_read_cstr
(struct ssp_rng* rng,
+ const char* cstr); /* Null terminated string */
+
+SSP_API res_T
+ssp_rng_write
+ (const struct ssp_rng* rng,
FILE* stream);
+SSP_API res_T
+ssp_rng_write_cstr
+ (const struct ssp_rng* rng,
+ char* buf, /* May be NULL */
+ const size_t bufsz, /* buf capacity */
+ size_t* len); /* May be NULL. #chars to write into buf without null char */
+
SSP_API double
ssp_rng_entropy
(const struct ssp_rng* rng);
@@ -238,11 +268,7 @@ ssp_rng_proxy_create_from_rng
SSP_API res_T
ssp_rng_proxy_create2
(struct mem_allocator* mem_allocator,
- const struct ssp_rng_type* type,
- const size_t sequence_offset, /* #RNs before the 1st valid sequence */
- const size_t sequence_size, /* #RNs in a sequence */
- const size_t sequence_pitch, /* #RNs between 2 consecutive sequence */
- const size_t nbuckets, /* #buckets in sequence */
+ const struct ssp_rng_proxy_create2_args* args,
struct ssp_rng_proxy** out_proxy);
SSP_API res_T
diff --git a/src/ssp_rng.c b/src/ssp_rng.c
@@ -107,19 +107,19 @@ rng_kiss_read(void* data, FILE* file)
{
struct rng_kiss* rng = (struct rng_kiss*)data;
int n;
- res_T res = RES_OK;
ASSERT(data && file);
+ n = fscanf(file, "%u %u %u %u\n", &rng->x, &rng->y, &rng->z, &rng->c);
+ return (n == EOF || n < 4) ? RES_IO_ERR : RES_OK;
+}
- n = fscanf(file, "%u %u %u %u", &rng->x, &rng->y, &rng->z, &rng->c);
- if(n == EOF || n < 4) {
- res = RES_IO_ERR;
- goto error;
- }
-
-exit:
- return res;
-error:
- goto exit;
+static res_T
+rng_kiss_read_cstr(void* data, const char* cstr)
+{
+ struct rng_kiss* rng = (struct rng_kiss*)data;
+ int n;
+ ASSERT(data && cstr);
+ n = sscanf(cstr, "%u %u %u %u\n", &rng->x, &rng->y, &rng->z, &rng->c);
+ return (n == EOF || n < 4) ? RES_IO_ERR : RES_OK;
}
static res_T
@@ -133,6 +133,26 @@ rng_kiss_write(const void* data, FILE* file)
}
static res_T
+rng_kiss_write_cstr
+ (const void* data,
+ char* buf,
+ const size_t bufsz,
+ size_t* out_len)
+{
+ const struct rng_kiss* rng = (const struct rng_kiss*)data;
+ int len = 0;
+ ASSERT(data);
+
+ len = snprintf(buf, bufsz, "%u %u %u %u\n", rng->x, rng->y, rng->z, rng->c);
+ CHK(len > 0);
+ if((size_t)len >= (bufsz - 1/*null char*/)) {
+ buf[bufsz-1] = '\0';
+ }
+ if(out_len) *out_len = (size_t)len;
+ return RES_OK;
+}
+
+static res_T
rng_kiss_init(struct mem_allocator* allocator, void* data)
{
(void)allocator;
@@ -170,7 +190,9 @@ const struct ssp_rng_type ssp_rng_kiss = {
rng_kiss_get,
rng_kiss_discard,
rng_kiss_read,
+ rng_kiss_read_cstr,
rng_kiss_write,
+ rng_kiss_write_cstr,
rng_kiss_entropy,
0,
UINT32_MAX,
@@ -231,6 +253,37 @@ rng_cxx_write<RAN_NAMESPACE::random_device>(const void* data, FILE* file)
template<typename RNG>
static res_T
+rng_cxx_write_cstr
+ (const void* data,
+ char* buf,
+ const size_t bufsz,
+ size_t* out_len)
+{
+ int len = 0;
+ std::stringstream stream;
+ RNG* rng = (RNG*)data;
+ ASSERT(rng);
+ stream << *rng << std::endl;
+ len = snprintf(buf, bufsz, "%s", stream.str().c_str());
+ CHK(len > 0);
+ if((size_t)len >= (bufsz - 1/*null char*/)) {
+ buf[bufsz-1] = '\0';
+ }
+ if(out_len) *out_len = (size_t)len;
+ return RES_OK;
+}
+
+template<>
+res_T
+rng_cxx_write_cstr<RAN_NAMESPACE::random_device>
+ (const void* data, char* buf, const size_t bufsz, size_t* out_len)
+{
+ (void)data; (void)buf, (void)bufsz, (void)out_len;
+ return RES_BAD_OP;
+}
+
+template<typename RNG>
+static res_T
rng_cxx_read(void* data, FILE* file)
{
std::stringstream stream;
@@ -250,7 +303,27 @@ template<>
res_T
rng_cxx_read<RAN_NAMESPACE::random_device>(void* data, FILE* file)
{
- (void) data; (void) file;
+ (void) data; (void)file;
+ return RES_BAD_OP;
+}
+
+template<typename RNG>
+static res_T
+rng_cxx_read_cstr(void* data, const char* cstr)
+{
+ std::stringstream stream;
+ RNG* rng = (RNG*)data;
+ ASSERT(rng && cstr && cstr[strlen(cstr)-1] == '\n');
+ stream << std::string(cstr);
+ stream >> *rng;
+ return stream.fail() ? RES_IO_ERR : RES_OK;
+}
+
+template<>
+res_T
+rng_cxx_read_cstr<RAN_NAMESPACE::random_device>(void* data, const char* cstr)
+{
+ (void)data, (void)cstr;
return RES_BAD_OP;
}
@@ -318,7 +391,9 @@ const struct ssp_rng_type ssp_rng_mt19937_64 = {
rng_cxx_get<RAN_NAMESPACE::mt19937_64>,
rng_cxx_discard<RAN_NAMESPACE::mt19937_64>,
rng_cxx_read<RAN_NAMESPACE::mt19937_64>,
+ rng_cxx_read_cstr<RAN_NAMESPACE::mt19937_64>,
rng_cxx_write<RAN_NAMESPACE::mt19937_64>,
+ rng_cxx_write_cstr<RAN_NAMESPACE::mt19937_64>,
rng_cxx_entropy<RAN_NAMESPACE::mt19937_64>,
RAN_NAMESPACE::mt19937_64::min(),
RAN_NAMESPACE::mt19937_64::max(),
@@ -334,7 +409,9 @@ const struct ssp_rng_type ssp_rng_ranlux48 = {
rng_cxx_get<RAN_NAMESPACE::ranlux48>,
rng_cxx_discard<RAN_NAMESPACE::ranlux48>,
rng_cxx_read<RAN_NAMESPACE::ranlux48>,
+ rng_cxx_read_cstr<RAN_NAMESPACE::ranlux48>,
rng_cxx_write<RAN_NAMESPACE::ranlux48>,
+ rng_cxx_write_cstr<RAN_NAMESPACE::ranlux48>,
rng_cxx_entropy<RAN_NAMESPACE::ranlux48>,
RAN_NAMESPACE::ranlux48::min(),
RAN_NAMESPACE::ranlux48::max(),
@@ -350,7 +427,9 @@ const struct ssp_rng_type ssp_rng_random_device = {
rng_cxx_get<RAN_NAMESPACE::random_device>,
rng_cxx_discard<RAN_NAMESPACE::random_device>,
rng_cxx_read<RAN_NAMESPACE::random_device>,
+ rng_cxx_read_cstr<RAN_NAMESPACE::random_device>,
rng_cxx_write<RAN_NAMESPACE::random_device>,
+ rng_cxx_write_cstr<RAN_NAMESPACE::random_device>,
rng_cxx_entropy<RAN_NAMESPACE::random_device>,
RAN_NAMESPACE::random_device::min(),
RAN_NAMESPACE::random_device::max(),
@@ -390,7 +469,9 @@ const struct ssp_rng_type ssp_rng_threefry = {
rng_cxx_get<threefry_T>,
rng_cxx_discard<threefry_T>,
rng_cxx_read<threefry_T>,
+ rng_cxx_read_cstr<threefry_T>,
rng_cxx_write<threefry_T>,
+ rng_cxx_write_cstr<threefry_T>,
rng_cxx_entropy<threefry_T>,
threefry_T::min(),
threefry_T::max(),
@@ -407,7 +488,9 @@ const struct ssp_rng_type ssp_rng_aes = {
rng_cxx_get<aes_T>,
rng_cxx_discard<aes_T>,
rng_cxx_read<aes_T>,
+ rng_cxx_read_cstr<aes_T>,
rng_cxx_write<aes_T>,
+ rng_cxx_write_cstr<aes_T>,
rng_cxx_entropy<aes_T>,
aes_T::min(),
aes_T::max(),
@@ -643,12 +726,30 @@ ssp_rng_read(struct ssp_rng* rng, FILE* stream)
}
res_T
+ssp_rng_read_cstr(struct ssp_rng* rng, const char* cstr)
+{
+ if(!rng || !cstr) return RES_BAD_ARG;
+ return rng->type.read_cstr(rng->state, cstr);
+}
+
+res_T
ssp_rng_write(const struct ssp_rng* rng, FILE* stream)
{
if(!rng || !stream) return RES_BAD_ARG;
return rng->type.write(rng->state, stream);
}
+res_T
+ssp_rng_write_cstr
+ (const struct ssp_rng* rng,
+ char* buf,
+ const size_t bufsz,
+ size_t* len)
+{
+ if(!rng) return RES_BAD_ARG;
+ return rng->type.write_cstr(rng->state, buf, bufsz, len);
+}
+
double
ssp_rng_entropy(const struct ssp_rng* rng)
{
diff --git a/src/ssp_rng_proxy.c b/src/ssp_rng_proxy.c
@@ -31,6 +31,7 @@
#include "ssp_rng_c.h"
+#include <rsys/dynamic_array_char.h>
#include <rsys/mutex.h>
#include <rsys/ref_count.h>
#include <rsys/signal.h>
@@ -38,12 +39,19 @@
#include <limits.h>
-#define BUCKET_SIZE_DEFAULT 1000000
+#define BUCKET_SIZE_DEFAULT 1000000 /* #RNs per bucket */
+#define STATE_CACHE_HINT_MAX_SIZE (32*(1024*1024)) /* 32 MB */
-/* FIFO list of RNG states */
+/* Cache of RNG states */
struct rng_state_cache {
- FILE* stream; /* Stream in which the RNG states are stored */
- long head, tail; /* Position onto the head/tail `states' stream */
+ struct darray_char state; /* Save the next RNG state with 'no_wstream' */
+ struct darray_char state_scratch; /* Scracth state buffer */
+ FILE* stream; /* Stream into which the RNG states are stored */
+ size_t state_pitch; /* #RNs between 2 cached states */
+ size_t nstates; /* #cached states */
+ long read, write; /* Offset into the stream where to read/write RNG states */
+ int no_wstream; /* Define if the RNG states are no more written to a stream */
+ int no_rstream; /* Define if the RNG states are no more read from a stream */
};
CLBK(rng_proxy_cb_T, ARG1(const struct ssp_rng_proxy*));
@@ -88,7 +96,7 @@ struct ssp_rng_proxy {
};
/* Return a RNG with a pool of `bucket_size' indenpendant random numbers. Each
- * pool are ensure to be independant per `bucket_id' in [0, N) and per function
+ * pool are ensured to be independant per `bucket_id' in [0, N) and per function
* call, i.e. calling this function X times with the same bucket_id will
* provide X different random pools.
*
@@ -107,16 +115,58 @@ rng_proxy_next_ran_pool
(struct ssp_rng_proxy* proxy,
const size_t bucket_id);
+/* Write the RNG state into buf. State data are terminated by a null char */
+static res_T
+rng_write_cstr
+ (const struct ssp_rng* rng,
+ struct darray_char* buf,
+ size_t* out_len) /* May be NULL. String length without the null char */
+{
+ size_t len;
+ res_T res = RES_OK;
+ ASSERT(rng && buf);
+
+ /* Write the RNG state into a temporary buffer */
+ res = ssp_rng_write_cstr
+ (rng, darray_char_data_get(buf), darray_char_size_get(buf), &len);
+ if(res != RES_OK) goto error;
+
+ /* Not sufficient space to store the state */
+ if(len >= darray_char_size_get(buf)) {
+ res = darray_char_resize(buf, len + 1/*null char*/);
+ if(res != RES_OK) goto error;
+
+ res = ssp_rng_write_cstr
+ (rng, darray_char_data_get(buf), darray_char_size_get(buf), &len);
+ if(res != RES_OK) goto error;
+ ASSERT(len + 1/*null char*/ == darray_char_size_get(buf));
+ }
+
+ if(out_len) *out_len = len;
+
+exit:
+ return res;
+error:
+ goto exit;
+}
+
/*******************************************************************************
* Cache of RNG states
******************************************************************************/
static res_T
-rng_state_cache_init(struct rng_state_cache* cache)
+rng_state_cache_init
+ (struct mem_allocator* allocator,
+ const size_t state_pitch, /* #RNs between cached states */
+ struct rng_state_cache* cache)
{
ASSERT(cache);
+ memset(cache, 0, sizeof(*cache));
+ darray_char_init(allocator, &cache->state);
+ darray_char_init(allocator, &cache->state_scratch);
cache->stream = tmpfile();
if(!cache->stream) return RES_IO_ERR;
- cache->head = cache->tail = ftell(cache->stream);
+ cache->read = cache->write = ftell(cache->stream);
+ cache->state_pitch = state_pitch;
return RES_OK;
}
@@ -125,48 +175,126 @@ rng_state_cache_release(struct rng_state_cache* cache)
{
ASSERT(cache);
if(cache->stream) fclose(cache->stream);
+ darray_char_release(&cache->state);
+ darray_char_release(&cache->state_scratch);
}
static char
rng_state_cache_is_empty(struct rng_state_cache* cache)
{
ASSERT(cache);
- return cache->head == cache->tail;
+ return cache->nstates == 0;
}
static res_T
rng_state_cache_read(struct rng_state_cache* cache, struct ssp_rng* rng)
{
- res_T res;
+ res_T res = RES_OK;
ASSERT(cache && rng && !rng_state_cache_is_empty(cache));
- /* Read the rng state from the stream */
- fseek(cache->stream, cache->head, SEEK_SET);
- res = ssp_rng_read(rng, cache->stream);
- if(res != RES_OK) return res;
- cache->head = ftell(cache->stream);
-
- /* Flush the state cache stream if there is no more RNG state */
- if(rng_state_cache_is_empty(cache)) {
+ if(!cache->no_rstream
+ && cache->read == cache->write
+ && cache->nstates == 1/* A state is saved in 'cache->state' */) {
+ /* There is not more data cached into the stream. Close the stream and do
+ * not rely anymore on the proxy RNG to generate the RNG states */
fclose(cache->stream);
- cache->stream = tmpfile();
- if(!cache->stream) return RES_IO_ERR;
- cache->head = cache->tail = ftell(cache->stream);
+ cache->stream = NULL;
+ cache->no_rstream = 1;
}
- return RES_OK;
+ /* Read the cached RNG state from the stream */
+ if(!cache->no_rstream) {
+ fseek(cache->stream, cache->read, SEEK_SET);
+ res = ssp_rng_read(rng, cache->stream);
+ if(res != RES_OK) goto error;
+ cache->read = ftell(cache->stream);
+
+ /* The fp reaches the end of the cached data */
+ if(cache->read >= STATE_CACHE_HINT_MAX_SIZE) {
+ cache->read = 0;
+ }
+
+ /* Remove one cached states */
+ cache->nstates -= 1;
+
+ /* Generate the next RNG state and load the cached one */
+ } else {
+ /* Copy the cached RNG state */
+ res = darray_char_copy(&cache->state_scratch, &cache->state);
+ if(res != RES_OK) goto error;
+
+ /* Load the cached RNG state */
+ res = ssp_rng_read_cstr(rng, darray_char_cdata_get(&cache->state));
+ if(res != RES_OK) goto error;
+
+ /* Setup the next RNG state */
+ res = ssp_rng_discard(rng, cache->state_pitch);
+ if(res != RES_OK) goto error;
+
+ /* Save the next RNG state */
+ res = rng_write_cstr(rng, &cache->state, NULL);
+ if(res != RES_OK) goto error;
+
+ /* Setup the current RNG state */
+ res = ssp_rng_read_cstr(rng, darray_char_cdata_get(&cache->state_scratch));
+ if(res != RES_OK) goto error;
+ }
+
+exit:
+ return res;
+error:
+ goto exit;
}
static res_T
rng_state_cache_write(struct rng_state_cache* cache, struct ssp_rng* rng)
{
- res_T res;
+ res_T res = RES_OK;
ASSERT(cache && rng);
- fseek(cache->stream, cache->tail, SEEK_SET);
- res = ssp_rng_write(rng, cache->stream);
- if(res != RES_OK) return res;
- cache->tail = ftell(cache->stream);
- return RES_OK;
+
+ if(cache->no_wstream) goto exit; /* Do not cache the submitted state */
+
+ fseek(cache->stream, cache->write, SEEK_SET);
+ if(rng_state_cache_is_empty(cache) || cache->write > cache->read) {
+ /* Directly write the RNG state into the cache stream */
+ res = ssp_rng_write(rng, cache->stream);
+ if(res != RES_OK) goto error;
+ cache->write = ftell(cache->stream);
+
+ /* The fp exceed the amount of cached data */
+ if(cache->write >= STATE_CACHE_HINT_MAX_SIZE) {
+ cache->write = 0;
+ }
+
+ } else {
+ size_t len;
+ res = rng_write_cstr(rng, &cache->state, &len);
+ if(res != RES_OK) goto error;
+
+ if(len > (size_t)(cache->read - cache->write)) {
+ /* No sufficient space into the cache stream to save the RNG state */
+ cache->no_wstream = 1;
+ } else {
+ /* Write the RNG state into the cached stream */
+ size_t sz;
+ sz = fwrite(darray_char_cdata_get(&cache->state), 1, len, cache->stream);
+ if(sz != len) { res = RES_IO_ERR; goto error; }
+ cache->write = ftell(cache->stream);
+
+ /* The fp exceed the amount of cached data */
+ if(cache->write >= STATE_CACHE_HINT_MAX_SIZE) {
+ cache->write = 0;
+ }
+ }
+ }
+
+ /* Update the number of cached states */
+ cache->nstates += 1;
+
+exit:
+ return res;
+error:
+ goto exit;
}
/*******************************************************************************
@@ -224,6 +352,13 @@ rng_bucket_read(void* data, FILE* file)
}
static res_T
+rng_bucket_read_cstr(void* data, const char* cstr)
+{
+ (void)data, (void)cstr;
+ return RES_BAD_OP;
+}
+
+static res_T
rng_bucket_write(const void* data, FILE* file)
{
(void)data, (void)file;
@@ -231,6 +366,17 @@ rng_bucket_write(const void* data, FILE* file)
}
static res_T
+rng_bucket_write_cstr
+ (const void* data,
+ char* buf,
+ const size_t bufsz,
+ size_t* len)
+{
+ (void)data, (void)buf, (void)bufsz, (void)len;
+ return RES_BAD_OP;
+}
+
+static res_T
rng_bucket_init(struct mem_allocator* allocator, void* data)
{
struct rng_bucket* rng = (struct rng_bucket*)data;
@@ -280,7 +426,9 @@ static const struct ssp_rng_type RNG_BUCKET_NULL = {
rng_bucket_get,
rng_bucket_discard,
rng_bucket_read,
+ rng_bucket_read_cstr,
rng_bucket_write,
+ rng_bucket_write_cstr,
rng_bucket_entropy,
INT_MAX, /* Min dummy value */
0, /* Max dummy value */
@@ -341,12 +489,15 @@ rng_proxy_clear(struct ssp_rng_proxy* proxy)
}
static res_T
-rng_proxy_setup(struct ssp_rng_proxy* proxy, const size_t nbuckets)
+rng_proxy_setup
+ (struct ssp_rng_proxy* proxy,
+ const size_t sequence_pitch, /* #RNs between 2 consecutive sequences */
+ const size_t nbuckets)
{
size_t ibucket;
res_T res = RES_OK;
- ASSERT(proxy && nbuckets);
+ ASSERT(proxy && sequence_pitch && nbuckets);
rng_proxy_clear(proxy);
sa_add(proxy->states, nbuckets);
@@ -354,7 +505,8 @@ rng_proxy_setup(struct ssp_rng_proxy* proxy, const size_t nbuckets)
sa_add(proxy->buckets, nbuckets);
FOR_EACH(ibucket, 0, nbuckets) {
- res = rng_state_cache_init(proxy->states+ibucket);
+ res = rng_state_cache_init
+ (proxy->allocator, sequence_pitch, proxy->states+ibucket);
if(res != RES_OK) goto error;
res = ssp_rng_create(proxy->allocator, &proxy->type, proxy->pools+ibucket);
if(res != RES_OK) goto error;
@@ -378,7 +530,7 @@ rng_proxy_release(ref_T* ref)
sa_release(proxy->states);
sa_release(proxy->pools);
sa_release(proxy->buckets);
- SSP(rng_ref_put(proxy->rng));
+ if(proxy->rng) SSP(rng_ref_put(proxy->rng));
if(proxy->mutex) mutex_destroy(proxy->mutex);
MEM_RM(proxy->allocator, proxy);
}
@@ -393,124 +545,106 @@ ssp_rng_proxy_create
const size_t nbuckets,
struct ssp_rng_proxy** out_proxy)
{
+ struct ssp_rng_proxy_create2_args args = SSP_RNG_PROXY_CREATE2_ARGS_NULL;
const size_t sz = BUCKET_SIZE_DEFAULT * nbuckets;
- return ssp_rng_proxy_create2
- (mem_allocator, type, 0, sz, sz, nbuckets, out_proxy);
+ args.type = type;
+ args.sequence_offset = 0;
+ args.sequence_size = sz;
+ args.sequence_pitch = sz;
+ args.nbuckets = nbuckets;
+ return ssp_rng_proxy_create2(mem_allocator, &args, out_proxy);
}
res_T
-ssp_rng_proxy_create2
+ssp_rng_proxy_create_from_rng
(struct mem_allocator* mem_allocator,
- const struct ssp_rng_type* type,
- const size_t sequence_offset, /* #RNs before the 1st valid sequence */
- const size_t sequence_size, /* #RNs in a sequence */
- const size_t sequence_pitch, /* #RNs between 2 consecutive sequences */
- const size_t nbuckets, /* #buckets in a sequence */
+ const struct ssp_rng* rng,
+ const size_t nbuckets,
struct ssp_rng_proxy** out_proxy)
{
- struct mem_allocator* allocator = NULL;
- struct ssp_rng_proxy* proxy = NULL;
- size_t i;
- res_T res = RES_OK;
-
- if(!type || !out_proxy || !sequence_size || sequence_pitch < sequence_size
- || !nbuckets || sequence_size < nbuckets) {
- res = RES_BAD_ARG;
- goto error;
- }
-
- allocator = mem_allocator ? mem_allocator : &mem_default_allocator;
- proxy = (struct ssp_rng_proxy*)
- MEM_CALLOC(allocator, 1, sizeof(struct ssp_rng_proxy));
- if(!proxy) {
- res = RES_MEM_ERR;
- goto error;
- }
- proxy->allocator = allocator;
- ref_init(&proxy->ref);
- proxy->bucket_size = sequence_size / nbuckets;
- proxy->sequence_bias = sequence_pitch - (proxy->bucket_size * nbuckets);
-
- res = ssp_rng_create(allocator, type, &proxy->rng);
- if(res != RES_OK) goto error;
- proxy->type = *type;
-
- res = ssp_rng_discard(proxy->rng, sequence_offset);
- if(res != RES_OK) goto error;
-
- proxy->mutex = mutex_create();
- if(!proxy->mutex) {
- res = RES_MEM_ERR;
- goto error;
- }
-
- FOR_EACH(i, 0, RNG_PROXY_SIGS_COUNT__) {
- SIG_INIT(proxy->signals + i);
- }
-
- res = rng_proxy_setup(proxy, nbuckets);
- if(res != RES_OK) goto error;
-
-exit:
- if(out_proxy) *out_proxy = proxy;
- return res;
-error:
- if(proxy) {
- SSP(rng_proxy_ref_put(proxy));
- proxy = NULL;
- }
- goto exit;
+ struct ssp_rng_proxy_create2_args args = SSP_RNG_PROXY_CREATE2_ARGS_NULL;
+ const size_t sz = BUCKET_SIZE_DEFAULT * nbuckets;
+ args.rng = rng;
+ args.sequence_offset = 0;
+ args.sequence_size = sz;
+ args.sequence_pitch = sz;
+ args.nbuckets = nbuckets;
+ return ssp_rng_proxy_create2(mem_allocator, &args, out_proxy);
}
res_T
-ssp_rng_proxy_create_from_rng
+ssp_rng_proxy_create2
(struct mem_allocator* mem_allocator,
- const struct ssp_rng* rng,
- const size_t nbuckets,
+ const struct ssp_rng_proxy_create2_args* args,
struct ssp_rng_proxy** out_proxy)
{
+ struct darray_char buf;
struct mem_allocator* allocator = NULL;
struct ssp_rng_proxy* proxy = NULL;
- struct ssp_rng_type type;
- FILE* stream = NULL;
size_t i;
res_T res = RES_OK;
- if(!rng || !out_proxy || !nbuckets) {
+ darray_char_init(mem_allocator, &buf);
+
+ if(!args
+ || !out_proxy
+ || !args->sequence_size
+ || !args->nbuckets
+ || (!args->type && !args->rng)
+ || args->sequence_pitch < args->sequence_size
+ || args->sequence_size < args->nbuckets) {
res = RES_BAD_ARG;
goto error;
}
allocator = mem_allocator ? mem_allocator : &mem_default_allocator;
- proxy = (struct ssp_rng_proxy*)
- MEM_CALLOC(allocator, 1, sizeof(struct ssp_rng_proxy));
+ proxy = (struct ssp_rng_proxy*)MEM_CALLOC(allocator, 1, sizeof(*proxy));
if(!proxy) {
res = RES_MEM_ERR;
goto error;
}
proxy->allocator = allocator;
ref_init(&proxy->ref);
- proxy->bucket_size = BUCKET_SIZE_DEFAULT;
- proxy->sequence_bias = 1;
+ proxy->bucket_size = args->sequence_size / args->nbuckets;
+ proxy->sequence_bias =
+ args->sequence_pitch - (proxy->bucket_size * args->nbuckets);
- res = ssp_rng_get_type(rng, &type);
- if(res != RES_OK) goto error;
+ /* Create the proxy RNG in its default state */
+ if(!args->rng) {
+ res = ssp_rng_create(allocator, args->type, &proxy->rng);
+ if(res != RES_OK) goto error;
+ proxy->type = *args->type;
- res = ssp_rng_create(allocator, &type, &proxy->rng);
- if(res != RES_OK) goto error;
- proxy->type = type;
+ /* Create the proxy RNG from a submitted RNG state */
+ } else {
+ size_t len;
- stream = tmpfile();
- if(!stream) {
- res = RES_IO_ERR;
- goto error;
- }
+ /* Create the RNG proxy of the type of the submitted RNG. Simply Ignore the
+ * submitted RNG type if any */
+ res = ssp_rng_get_type(args->rng, &proxy->type);
+ if(res != RES_OK) goto error;
- res = ssp_rng_write(rng, stream);
- if(res != RES_OK) goto error;
+ /* Bucket RNG is not allowed to be a proxy RNG */
+ if(proxy->type.init == rng_bucket_init) {
+ res = RES_BAD_ARG;
+ goto error;
+ }
- rewind(stream);
- res = ssp_rng_read(proxy->rng, stream);
+ res = ssp_rng_create(allocator, &proxy->type, &proxy->rng);
+ if(res != RES_OK) goto error;
+
+ /* Initialise the RNG proxy state from the state of the submitted RNG */
+ res = ssp_rng_write_cstr(args->rng, NULL, 0, &len);
+ if(res != RES_OK) goto error;
+ res = darray_char_resize(&buf, len+1/*Null char*/);
+ if(res != RES_OK) goto error;
+ res = ssp_rng_write_cstr(args->rng, darray_char_data_get(&buf), len+1, &len);
+ if(res != RES_OK) goto error;
+ res = ssp_rng_read_cstr(proxy->rng, darray_char_cdata_get(&buf));
+ if(res != RES_OK) goto error;
+ }
+
+ res = ssp_rng_discard(proxy->rng, args->sequence_offset);
if(res != RES_OK) goto error;
proxy->mutex = mutex_create();
@@ -523,11 +657,11 @@ ssp_rng_proxy_create_from_rng
SIG_INIT(proxy->signals + i);
}
- res = rng_proxy_setup(proxy, nbuckets);
+ res = rng_proxy_setup(proxy, args->sequence_pitch, args->nbuckets);
if(res != RES_OK) goto error;
exit:
- if(stream) fclose(stream);
+ darray_char_release(&buf);
if(out_proxy) *out_proxy = proxy;
return res;
error:
diff --git a/src/test_ssp_rng.c b/src/test_ssp_rng.c
@@ -51,7 +51,9 @@ test_rng(const struct ssp_rng_type* type)
uint64_t datai1[NRAND];
double datad[NRAND];
float dataf[NRAND];
+ size_t len;
char buf[512];
+ char* cstr = NULL;
int i, j;
res_T r;
const char can_set = (type != &ssp_rng_random_device);
@@ -180,7 +182,7 @@ test_rng(const struct ssp_rng_type* type)
time_dump(&t0, TIME_SEC|TIME_MSEC|TIME_USEC, NULL, buf, sizeof(buf));
printf("1,000,000 random numbers in %s\n", buf);
- if (can_have_entropy) {
+ if(can_have_entropy) {
printf("Entropy for this implementation and system: %f\n",
ssp_rng_entropy(rng));
}
@@ -192,6 +194,15 @@ test_rng(const struct ssp_rng_type* type)
CHK(ssp_rng_write(NULL, stream) == RES_BAD_ARG);
CHK(ssp_rng_write(rng, stream) == (can_rw ? RES_OK : RES_BAD_OP));
+ CHK(ssp_rng_write_cstr(NULL, NULL, 0, &len) == RES_BAD_ARG);
+ CHK(ssp_rng_write_cstr(rng, NULL, 0, NULL) == (can_rw ? RES_OK : RES_BAD_OP));
+ CHK(ssp_rng_write_cstr(rng, NULL, 0, &len) == (can_rw ? RES_OK : RES_BAD_OP));
+ cstr = mem_calloc(len+1, 1);
+ CHK(ssp_rng_write_cstr(rng, cstr, len+1, NULL) == (can_rw ? RES_OK : RES_BAD_OP));
+
+ /* Reserialize the RNG state */
+ CHK(ssp_rng_write(rng, stream) == (can_rw ? RES_OK : RES_BAD_OP));
+
FOR_EACH(i, 0, NRAND)
datai0[i] = ssp_rng_get(rng);
@@ -200,14 +211,37 @@ test_rng(const struct ssp_rng_type* type)
CHK(ssp_rng_read(NULL, stream) == RES_BAD_ARG);
CHK(ssp_rng_read(rng, stream) == (can_rw ? RES_IO_ERR : RES_BAD_OP));
rewind(stream);
+
+ /* Read the first state of the stream */
CHK(ssp_rng_read(rng, stream) == (can_rw ? RES_OK : RES_BAD_OP));
+ if(can_rw) {
+ FOR_EACH(i, 0, NRAND) {
+ uint64_t rn = ssp_rng_get(rng);
+ CHK(rn == datai0[i]);
+ }
+ }
+
+ /* Read the second state of the stream */
+ CHK(ssp_rng_read(rng, stream) == (can_rw ? RES_OK : RES_BAD_OP));
+ if(can_rw) {
+ FOR_EACH(i, 0, NRAND) {
+ uint64_t rn = ssp_rng_get(rng);
+ CHK(rn == datai0[i]);
+ }
+ }
- if (can_rw) {
+ /* Read the RNG state from an in memory buffer */
+ CHK(ssp_rng_read_cstr(NULL, cstr) == RES_BAD_ARG);
+ CHK(ssp_rng_read_cstr(rng, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_read_cstr(rng, cstr) == (can_rw ? RES_OK : RES_BAD_OP));
+ if(can_rw) {
FOR_EACH(i, 0, NRAND) {
uint64_t rn = ssp_rng_get(rng);
CHK(rn == datai0[i]);
}
}
+
+ mem_rm(cstr);
fclose(stream);
CHK(ssp_rng_ref_put(rng) == RES_OK);
diff --git a/src/test_ssp_rng_proxy.c b/src/test_ssp_rng_proxy.c
@@ -73,52 +73,52 @@ test_creation(void)
static void
test_creation2(void)
{
- const struct ssp_rng_type* type = &ssp_rng_mt19937_64;
+ struct ssp_rng_proxy_create2_args args = SSP_RNG_PROXY_CREATE2_ARGS_NULL;
struct ssp_rng_proxy* proxy;
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 0, 0, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 0, 0, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 0, 0, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 0, 0, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 32, 0, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 32, 0, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 32, 0, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 0, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 0, 1, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 0, 1, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 0, 1, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 0, 1, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 32, 1, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 32, 1, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 32, 1, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 1, NULL) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 0, 0, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 0, 0, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 0, 0, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 0, 0, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 32, 0, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 32, 0, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 32, 0, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 0, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 0, 1, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 0, 1, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 0, 1, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 0, 1, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 32, 1, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 32, 1, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 32, 1, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 1, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_BAD_ARG);
+
+ args.type = &ssp_rng_mt19937_64;
+ args.sequence_offset = 0;
+ args.sequence_size = 32;
+ args.sequence_pitch = 32;
+ args.nbuckets = 1;
+ CHK(ssp_rng_proxy_create2(NULL, &args, NULL) == RES_BAD_ARG);
+
+ args.type = NULL;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_BAD_ARG);
+ args.type = &ssp_rng_mt19937_64;
+ args.sequence_size= 0;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_BAD_ARG);
+ args.sequence_size = 32;
+ args.sequence_pitch = 0;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_BAD_ARG);
+ args.sequence_pitch = 31;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_BAD_ARG);
+ args.sequence_pitch = 32;
+ args.nbuckets = 0;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_BAD_ARG);
+ args.nbuckets = 33;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_BAD_ARG);
+ args.nbuckets = 1;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_OK);
CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 4, &proxy) == RES_OK);
+ args.nbuckets = 4;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_OK);
CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 32, &proxy) == RES_OK);
+ args.nbuckets = 5;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_OK);
CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
- CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 33, &proxy) == RES_BAD_ARG);
- CHK(ssp_rng_proxy_create2
- (&mem_default_allocator, type, 1024, 32, 32, 4, &proxy) == RES_OK);
+ args.nbuckets = 32;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
+
+ args.sequence_offset = 1024;
+ args.nbuckets = 4;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_OK);
CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
}
@@ -165,6 +165,7 @@ test_rng_from_proxy(void)
static void
test_rng_from_proxy2(void)
{
+ struct ssp_rng_proxy_create2_args args = SSP_RNG_PROXY_CREATE2_ARGS_NULL;
struct ssp_rng_proxy* proxy[2];
struct ssp_rng* rng[4];
const size_t block_sz = 99;
@@ -177,8 +178,11 @@ test_rng_from_proxy2(void)
CHK((r[2] = mem_alloc(sizeof(uint64_t)*nrands)) != NULL);
CHK((r[3] = mem_alloc(sizeof(uint64_t)*nrands)) != NULL);
- CHK(ssp_rng_proxy_create2
- (NULL, &ssp_rng_mt19937_64, 0, block_sz, block_sz, 4, &proxy[0]) == RES_OK);
+ args.type = &ssp_rng_mt19937_64;
+ args.sequence_size = block_sz;
+ args.sequence_pitch = block_sz;
+ args.nbuckets = 4;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy[0]) == RES_OK);
CHK(ssp_rng_proxy_create_rng(proxy[0], 0, &rng[0]) == RES_OK);
CHK(ssp_rng_proxy_create_rng(proxy[0], 1, &rng[1]) == RES_OK);
@@ -210,11 +214,16 @@ test_rng_from_proxy2(void)
CHK(ssp_rng_ref_put(rng[1]) == RES_OK);
CHK(ssp_rng_ref_put(rng[2]) == RES_OK);
CHK(ssp_rng_ref_put(rng[3]) == RES_OK);
-
- CHK(ssp_rng_proxy_create2(NULL, &ssp_rng_mt19937_64,
- 0, block_sz, 2*block_sz, 2, &proxy[0]) == RES_OK);
- CHK(ssp_rng_proxy_create2(NULL, &ssp_rng_mt19937_64,
- block_sz, block_sz, 2*block_sz, 2, &proxy[1]) == RES_OK);
+
+ args.type = &ssp_rng_mt19937_64;
+ args.sequence_size = block_sz;
+ args.sequence_pitch = 2*block_sz;
+ args.nbuckets = 2;
+
+ args.sequence_offset = 0;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy[0]) == RES_OK);
+ args.sequence_offset = block_sz;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy[1]) == RES_OK);
CHK(ssp_rng_proxy_create_rng(proxy[0], 0, &rng[0]) == RES_OK);
CHK(ssp_rng_proxy_create_rng(proxy[0], 1, &rng[1]) == RES_OK);
@@ -289,6 +298,7 @@ test_multi_proxies(void)
static void
test_proxy_from_rng(void)
{
+ struct ssp_rng_proxy_create2_args args = SSP_RNG_PROXY_CREATE2_ARGS_NULL;
struct ssp_rng_proxy* proxy;
struct ssp_rng* rng[4];
struct ssp_rng_type type;
@@ -333,6 +343,35 @@ test_proxy_from_rng(void)
FOR_EACH(k, 0, j) CHK(r[k] != r[j]);
}
}
+
+ FOR_EACH(i, 1, 4) CHK(ssp_rng_ref_put(rng[i]) == RES_OK);
+
+ args.rng = rng[0];
+ args.sequence_offset = 0;
+ args.sequence_size = 4000;
+ args.sequence_pitch = 4000;
+ args.nbuckets = 4;
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_ref_put(rng[0]) == RES_OK);
+
+ CHK(ssp_rng_create(NULL, &ssp_rng_threefry, &rng[0]) == RES_OK);
+ CHK(ssp_rng_discard(rng[0], 100) == RES_OK);
+
+ args.rng = rng[0];
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_OK);
+ CHK(ssp_rng_ref_put(rng[0]) == RES_OK);
+ FOR_EACH(i, 0, 4) {
+ CHK(ssp_rng_proxy_create_rng(proxy, i, &rng[i]) == RES_OK);
+ }
+
+ FOR_EACH(i, 0, NRANDS) {
+ FOR_EACH(j, 0, 4) {
+ r[j] = ssp_rng_get(rng[j]);
+ FOR_EACH(k, 0, j) CHK(r[k] != r[j]);
+ }
+ }
+
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
FOR_EACH(i, 0, 4) CHK(ssp_rng_ref_put(rng[i]) == RES_OK);
}
@@ -417,6 +456,82 @@ test_write(void)
fclose(stream);
}
+static void
+test_cache(void)
+{
+ struct ssp_rng_proxy_create2_args args = SSP_RNG_PROXY_CREATE2_ARGS_NULL;
+ struct ssp_rng_proxy* proxy;
+ struct ssp_rng* rng0;
+ struct ssp_rng* rng1;
+ struct ssp_rng* rng;
+ const size_t nrands = 20000;
+ size_t i;
+
+ /* Create a proxy with a very small sequence size of 2 RNs per bucket in
+ * order to maximize the number of cached states. Furthermore, use the
+ * Mersenne Twister RNG type since its internal state is the greatest one of
+ * the proposed builtin type and is thus the one that will fill quickly the
+ * cache stream. */
+ args.type = &ssp_rng_mt19937_64;
+ args.sequence_size = 4;
+ args.sequence_pitch = 4;
+ args.nbuckets = 2;
+
+ /* Simply test that the RNs generated by the proxy are the same thant the
+ * ones generated by a regular RNG. Since each RNG invocation are
+ * interleaved, the cache pressure is very low, at most 1 RNG state is
+ * cached. */
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy, 0, &rng0) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy, 1, &rng1) == RES_OK);
+ CHK(ssp_rng_create(NULL, &ssp_rng_mt19937_64, &rng) == RES_OK);
+ FOR_EACH(i, 0, nrands*2) {
+ if((i / 2) % 2) {
+ CHK(ssp_rng_get(rng1) == ssp_rng_get(rng));
+ } else {
+ CHK(ssp_rng_get(rng0) == ssp_rng_get(rng));
+ }
+ }
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
+ CHK(ssp_rng_ref_put(rng0) == RES_OK);
+ CHK(ssp_rng_ref_put(rng1) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+
+ CHK(ssp_rng_proxy_create2(NULL, &args, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy, 0, &rng0) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy, 1, &rng1) == RES_OK);
+ CHK(ssp_rng_create(NULL, &ssp_rng_mt19937_64, &rng) == RES_OK);
+
+ /* Generate several RNs for the first RNG only to make under pressure the
+ * cache stream of 'rng1'. The cache stream limit is set to 32 MB and the
+ * size of a Mersenne Twister RNG state is greater than 6 KB. Consquently,
+ * ~5500 RNG states will exceed the cache stream, i.e. 5500*2 = 11000
+ * random generations (since there is 2 RNs per bucket). Above this limit,
+ * 'rng1' will not rely anymore on the proxy RNG to manage its state.
+ *
+ * For both RNGs, ensure that the generated RNs are the expected ones by
+ * comparing them to the ones generated by a regular RNG */
+ FOR_EACH(i, 0, nrands) {
+ CHK(ssp_rng_get(rng0) == ssp_rng_get(rng));
+ if(i % 2) CHK(ssp_rng_discard(rng, 2) == RES_OK);
+ }
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+
+ /* Check the cache mechanisme of rng1 */
+ CHK(ssp_rng_create(NULL, &ssp_rng_mt19937_64, &rng) == RES_OK);
+ CHK(ssp_rng_discard(rng, 2) == RES_OK);
+ FOR_EACH(i, 0, nrands) {
+ CHK(ssp_rng_get(rng1) == ssp_rng_get(rng));
+ if(i % 2) CHK(ssp_rng_discard(rng, 2) == RES_OK);
+ }
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
+ CHK(ssp_rng_ref_put(rng0) == RES_OK);
+ CHK(ssp_rng_ref_put(rng1) == RES_OK);
+
+}
+
int
main(int argc, char** argv)
{
@@ -429,6 +544,7 @@ main(int argc, char** argv)
test_proxy_from_rng();
test_read();
test_write();
+ test_cache();
CHK(mem_allocated_size() == 0);
return 0;
}
