move MT19937 random generator to ddsrt
Signed-off-by: Erik Boasson <eb@ilities.com>
This commit is contained in:
		
							parent
							
								
									83f3a51a47
								
							
						
					
					
						commit
						9bfac607a4
					
				
					 13 changed files with 345 additions and 264 deletions
				
			
		| 
						 | 
				
			
			@ -1261,7 +1261,7 @@ static ssize_t nn_xpack_send1 (const nn_locator_t *loc, void * varg)
 | 
			
		|||
  {
 | 
			
		||||
    /* We drop APPROXIMATELY a fraction of xmit_lossiness * 10**(-3)
 | 
			
		||||
       of all packets to be sent */
 | 
			
		||||
    if ((ddsrt_random () % 1000) < config.xmit_lossiness)
 | 
			
		||||
    if ((ddsrt_random () % 1000) < (uint32_t) config.xmit_lossiness)
 | 
			
		||||
    {
 | 
			
		||||
      DDS_TRACE("(dropped)");
 | 
			
		||||
      xp->call_flags = 0;
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -11,7 +11,7 @@
 | 
			
		|||
#
 | 
			
		||||
idlc_generate(RhcTypes RhcTypes.idl)
 | 
			
		||||
 | 
			
		||||
add_executable(rhc_torture rhc_torture.c mt19937ar.c mt19937ar.h)
 | 
			
		||||
add_executable(rhc_torture rhc_torture.c)
 | 
			
		||||
 | 
			
		||||
target_include_directories(
 | 
			
		||||
  rhc_torture PRIVATE
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -1,184 +0,0 @@
 | 
			
		|||
/*
 | 
			
		||||
 * Copyright(c) 2019 ADLINK Technology Limited and others
 | 
			
		||||
 *
 | 
			
		||||
 * This program and the accompanying materials are made available under the
 | 
			
		||||
 * terms of the Eclipse Public License v. 2.0 which is available at
 | 
			
		||||
 * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
 | 
			
		||||
 * v. 1.0 which is available at
 | 
			
		||||
 * http://www.eclipse.org/org/documents/edl-v10.php.
 | 
			
		||||
 *
 | 
			
		||||
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 | 
			
		||||
 */
 | 
			
		||||
 | 
			
		||||
/*
 | 
			
		||||
   A C-program for MT19937, with initialization improved 2002/1/26.
 | 
			
		||||
   Coded by Takuji Nishimura and Makoto Matsumoto.
 | 
			
		||||
 | 
			
		||||
   Before using, initialize the state by using init_genrand(seed)
 | 
			
		||||
   or init_by_array(init_key, key_length).
 | 
			
		||||
 | 
			
		||||
   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
 | 
			
		||||
   All rights reserved.
 | 
			
		||||
 | 
			
		||||
   Redistribution and use in source and binary forms, with or without
 | 
			
		||||
   modification, are permitted provided that the following conditions
 | 
			
		||||
   are met:
 | 
			
		||||
 | 
			
		||||
     1. Redistributions of source code must retain the above copyright
 | 
			
		||||
        notice, this list of conditions and the following disclaimer.
 | 
			
		||||
 | 
			
		||||
     2. Redistributions in binary form must reproduce the above copyright
 | 
			
		||||
        notice, this list of conditions and the following disclaimer in the
 | 
			
		||||
        documentation and/or other materials provided with the distribution.
 | 
			
		||||
 | 
			
		||||
     3. The names of its contributors may not be used to endorse or promote
 | 
			
		||||
        products derived from this software without specific prior written
 | 
			
		||||
        permission.
 | 
			
		||||
 | 
			
		||||
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 | 
			
		||||
   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 | 
			
		||||
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 | 
			
		||||
   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 | 
			
		||||
   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 | 
			
		||||
   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 | 
			
		||||
   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 | 
			
		||||
   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 | 
			
		||||
   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 | 
			
		||||
   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 | 
			
		||||
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
   Any feedback is very welcome.
 | 
			
		||||
   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
 | 
			
		||||
   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
 | 
			
		||||
*/
 | 
			
		||||
 | 
			
		||||
#include "mt19937ar.h"
 | 
			
		||||
 | 
			
		||||
/* Period parameters */
 | 
			
		||||
#define N 624
 | 
			
		||||
#define M 397
 | 
			
		||||
#define MATRIX_A 0x9908b0dfU   /* constant vector a */
 | 
			
		||||
#define UPPER_MASK 0x80000000U /* most significant w-r bits */
 | 
			
		||||
#define LOWER_MASK 0x7fffffffU /* least significant r bits */
 | 
			
		||||
 | 
			
		||||
static uint32_t mt[N]; /* the array for the state vector  */
 | 
			
		||||
static uint32_t mti=N+1; /* mti==N+1 means mt[N] is not initialized */
 | 
			
		||||
 | 
			
		||||
/* initializes mt[N] with a seed */
 | 
			
		||||
void init_genrand(uint32_t s)
 | 
			
		||||
{
 | 
			
		||||
    mt[0]= s & 0xffffffffU;
 | 
			
		||||
    for (mti=1; mti<N; mti++) {
 | 
			
		||||
        mt[mti] =
 | 
			
		||||
            (1812433253U * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
 | 
			
		||||
        /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
 | 
			
		||||
        /* In the previous versions, MSBs of the seed affect   */
 | 
			
		||||
        /* only MSBs of the array mt[].                        */
 | 
			
		||||
        /* 2002/01/09 modified by Makoto Matsumoto             */
 | 
			
		||||
        mt[mti] &= 0xffffffffU;
 | 
			
		||||
        /* for >32 bit machines */
 | 
			
		||||
    }
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* initialize by an array with array-length */
 | 
			
		||||
/* init_key is the array for initializing keys */
 | 
			
		||||
/* key_length is its length */
 | 
			
		||||
/* slight change for C++, 2004/2/26 */
 | 
			
		||||
void init_by_array(uint32_t init_key[], size_t key_length)
 | 
			
		||||
{
 | 
			
		||||
    uint32_t i, j, k;
 | 
			
		||||
    init_genrand(19650218U);
 | 
			
		||||
    i=1; j=0;
 | 
			
		||||
    k = (N>key_length ? N : (uint32_t)key_length);
 | 
			
		||||
    for (; k; k--) {
 | 
			
		||||
        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525U))
 | 
			
		||||
          + init_key[j] + j; /* non linear */
 | 
			
		||||
        mt[i] &= 0xffffffffU; /* for WORDSIZE > 32 machines */
 | 
			
		||||
        i++; j++;
 | 
			
		||||
        if (i>=N) { mt[0] = mt[N-1]; i=1; }
 | 
			
		||||
        if (j>=(uint32_t)key_length) j=0;
 | 
			
		||||
    }
 | 
			
		||||
    for (k=N-1; k; k--) {
 | 
			
		||||
        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941U))
 | 
			
		||||
          - i; /* non linear */
 | 
			
		||||
        mt[i] &= 0xffffffffU; /* for WORDSIZE > 32 machines */
 | 
			
		||||
        i++;
 | 
			
		||||
        if (i>=N) { mt[0] = mt[N-1]; i=1; }
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    mt[0] = 0x80000000U; /* MSB is 1; assuring non-zero initial array */
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* generates a random number on [0,0xffffffff]-interval */
 | 
			
		||||
uint32_t genrand_int32(void)
 | 
			
		||||
{
 | 
			
		||||
    uint32_t y;
 | 
			
		||||
    static uint32_t mag01[2]={0x0U, MATRIX_A};
 | 
			
		||||
    /* mag01[x] = x * MATRIX_A  for x=0,1 */
 | 
			
		||||
 | 
			
		||||
    if (mti >= N) { /* generate N words at one time */
 | 
			
		||||
        int kk;
 | 
			
		||||
 | 
			
		||||
        if (mti == N+1)   /* if init_genrand() has not been called, */
 | 
			
		||||
            init_genrand(5489U); /* a default initial seed is used */
 | 
			
		||||
 | 
			
		||||
        for (kk=0;kk<N-M;kk++) {
 | 
			
		||||
            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
 | 
			
		||||
            mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1U];
 | 
			
		||||
        }
 | 
			
		||||
        for (;kk<N-1;kk++) {
 | 
			
		||||
            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
 | 
			
		||||
            mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1U];
 | 
			
		||||
        }
 | 
			
		||||
        y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
 | 
			
		||||
        mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1U];
 | 
			
		||||
 | 
			
		||||
        mti = 0;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    y = mt[mti++];
 | 
			
		||||
 | 
			
		||||
    /* Tempering */
 | 
			
		||||
    y ^= (y >> 11);
 | 
			
		||||
    y ^= (y << 7) & 0x9d2c5680U;
 | 
			
		||||
    y ^= (y << 15) & 0xefc60000U;
 | 
			
		||||
    y ^= (y >> 18);
 | 
			
		||||
 | 
			
		||||
    return (uint32_t) y;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* generates a random number on [0,0x7fffffff]-interval */
 | 
			
		||||
int32_t genrand_int31(void)
 | 
			
		||||
{
 | 
			
		||||
    return (int32_t)(genrand_int32()>>1);
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* generates a random number on [0,1]-real-interval */
 | 
			
		||||
double genrand_real1(void)
 | 
			
		||||
{
 | 
			
		||||
    return genrand_int32()*(1.0/4294967295.0);
 | 
			
		||||
    /* divided by 2^32-1 */
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* generates a random number on [0,1)-real-interval */
 | 
			
		||||
double genrand_real2(void)
 | 
			
		||||
{
 | 
			
		||||
    return genrand_int32()*(1.0/4294967296.0);
 | 
			
		||||
    /* divided by 2^32 */
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* generates a random number on (0,1)-real-interval */
 | 
			
		||||
double genrand_real3(void)
 | 
			
		||||
{
 | 
			
		||||
    return (((double)genrand_int32()) + 0.5)*(1.0/4294967296.0);
 | 
			
		||||
    /* divided by 2^32 */
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
/* generates a random number on [0,1) with 53-bit resolution*/
 | 
			
		||||
double genrand_res53(void)
 | 
			
		||||
{
 | 
			
		||||
    uint32_t a=genrand_int32()>>5, b=genrand_int32()>>6;
 | 
			
		||||
    return(a*67108864.0+b)*(1.0/9007199254740992.0);
 | 
			
		||||
}
 | 
			
		||||
/* These real versions are due to Isaku Wada, 2002/01/09 added */
 | 
			
		||||
| 
						 | 
				
			
			@ -1,46 +0,0 @@
 | 
			
		|||
/*
 | 
			
		||||
 * Copyright(c) 2019 ADLINK Technology Limited and others
 | 
			
		||||
 *
 | 
			
		||||
 * This program and the accompanying materials are made available under the
 | 
			
		||||
 * terms of the Eclipse Public License v. 2.0 which is available at
 | 
			
		||||
 * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
 | 
			
		||||
 * v. 1.0 which is available at
 | 
			
		||||
 * http://www.eclipse.org/org/documents/edl-v10.php.
 | 
			
		||||
 *
 | 
			
		||||
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 | 
			
		||||
 */
 | 
			
		||||
#ifndef MT19937AR_H
 | 
			
		||||
#define MT19937AR_H
 | 
			
		||||
 | 
			
		||||
#include <stdint.h>
 | 
			
		||||
#include <stddef.h>
 | 
			
		||||
 | 
			
		||||
/* initializes mt[N] with a seed */
 | 
			
		||||
void init_genrand(uint32_t s);
 | 
			
		||||
 | 
			
		||||
/* initialize by an array with array-length */
 | 
			
		||||
/* init_key is the array for initializing keys */
 | 
			
		||||
/* key_length is its length */
 | 
			
		||||
/* slight change for C++, 2004/2/26 */
 | 
			
		||||
void init_by_array(uint32_t init_key[], size_t key_length);
 | 
			
		||||
 | 
			
		||||
/* generates a random number on [0,0xffffffff]-interval */
 | 
			
		||||
uint32_t genrand_int32(void);
 | 
			
		||||
 | 
			
		||||
/* generates a random number on [0,0x7fffffff]-interval */
 | 
			
		||||
int32_t genrand_int31(void);
 | 
			
		||||
 | 
			
		||||
/* generates a random number on [0,1]-real-interval */
 | 
			
		||||
double genrand_real1(void);
 | 
			
		||||
 | 
			
		||||
/* generates a random number on [0,1)-real-interval */
 | 
			
		||||
double genrand_real2(void);
 | 
			
		||||
 | 
			
		||||
/* generates a random number on (0,1)-real-interval */
 | 
			
		||||
double genrand_real3(void);
 | 
			
		||||
 | 
			
		||||
/* generates a random number on [0,1) with 53-bit resolution*/
 | 
			
		||||
double genrand_res53(void);
 | 
			
		||||
/* These real versions are due to Isaku Wada, 2002/01/09 added */
 | 
			
		||||
 | 
			
		||||
#endif
 | 
			
		||||
| 
						 | 
				
			
			@ -18,6 +18,7 @@
 | 
			
		|||
#include "dds/ddsrt/heap.h"
 | 
			
		||||
#include "dds/ddsrt/process.h"
 | 
			
		||||
#include "dds/ddsrt/sync.h"
 | 
			
		||||
#include "dds/ddsrt/random.h"
 | 
			
		||||
#include "dds/dds.h"
 | 
			
		||||
#include "dds/ddsi/ddsi_tkmap.h"
 | 
			
		||||
#include "dds__entity.h"
 | 
			
		||||
| 
						 | 
				
			
			@ -32,7 +33,6 @@
 | 
			
		|||
#include "dds__rhc.h"
 | 
			
		||||
#include "dds/ddsi/ddsi_iid.h"
 | 
			
		||||
 | 
			
		||||
#include "mt19937ar.h"
 | 
			
		||||
#include "RhcTypes.h"
 | 
			
		||||
 | 
			
		||||
#ifndef _MSC_VER
 | 
			
		||||
| 
						 | 
				
			
			@ -41,6 +41,8 @@
 | 
			
		|||
#define STATIC_ARRAY_DIM
 | 
			
		||||
#endif
 | 
			
		||||
 | 
			
		||||
static ddsrt_prng_t prng;
 | 
			
		||||
 | 
			
		||||
static struct ddsi_sertopic *mdtopic;
 | 
			
		||||
static struct thread_state1 *mainthread;
 | 
			
		||||
static dds_time_t tref_dds;
 | 
			
		||||
| 
						 | 
				
			
			@ -669,14 +671,14 @@ static void test_conditions (dds_entity_t pp, dds_entity_t tp, const int count,
 | 
			
		|||
  int lastprint_pct = 0;
 | 
			
		||||
  for (int i = 0; i < count; i++)
 | 
			
		||||
  {
 | 
			
		||||
    const int32_t keyval = (int32_t) (genrand_int32 () % N_KEYVALS);
 | 
			
		||||
    const uint32_t which = genrand_int32 () % 3;
 | 
			
		||||
    const int32_t keyval = (int32_t) (ddsrt_prng_random (&prng) % N_KEYVALS);
 | 
			
		||||
    const uint32_t which = ddsrt_prng_random (&prng) % 3;
 | 
			
		||||
    uint32_t oper_base;
 | 
			
		||||
    uint32_t oper;
 | 
			
		||||
 | 
			
		||||
    /* generate uniform number in range 0 .. N, then map to operation following the frequency table */
 | 
			
		||||
    do {
 | 
			
		||||
      oper_base = genrand_int32 ();
 | 
			
		||||
      oper_base = ddsrt_prng_random (&prng);
 | 
			
		||||
    } while (oper_base >= opthres[sizeof (opfreqs) / sizeof (opfreqs[0]) - 1]);
 | 
			
		||||
    for (oper = 0; oper < sizeof (opfreqs) / sizeof (opfreqs[0]); oper++)
 | 
			
		||||
    {
 | 
			
		||||
| 
						 | 
				
			
			@ -745,19 +747,19 @@ static void test_conditions (dds_entity_t pp, dds_entity_t tp, const int count,
 | 
			
		|||
          tkall (rhc[k], NULL, print && k == 0, states_seen);
 | 
			
		||||
        break;
 | 
			
		||||
      case 8: {
 | 
			
		||||
        uint32_t cond = genrand_int32 () % (uint32_t) nconds;
 | 
			
		||||
        uint32_t cond = ddsrt_prng_random (&prng) % (uint32_t) nconds;
 | 
			
		||||
        for (size_t k = 0; k < nrd; k++)
 | 
			
		||||
          rdcond (rhc[k], rhcconds[cond], NULL, 0, print && k == 0, states_seen);
 | 
			
		||||
        break;
 | 
			
		||||
      }
 | 
			
		||||
      case 9: {
 | 
			
		||||
        uint32_t cond = genrand_int32 () % (uint32_t) nconds;
 | 
			
		||||
        uint32_t cond = ddsrt_prng_random (&prng) % (uint32_t) nconds;
 | 
			
		||||
        for (size_t k = 0; k < nrd; k++)
 | 
			
		||||
          tkcond (rhc[k], rhcconds[cond], NULL, 0, print && k == 0, states_seen);
 | 
			
		||||
        break;
 | 
			
		||||
      }
 | 
			
		||||
      case 10: {
 | 
			
		||||
        uint32_t cond = genrand_int32 () % (uint32_t) nconds;
 | 
			
		||||
        uint32_t cond = ddsrt_prng_random (&prng) % (uint32_t) nconds;
 | 
			
		||||
        for (size_t k = 0; k < nrd; k++)
 | 
			
		||||
          tkcond (rhc[k], rhcconds[cond], NULL, 1, print && k == 0, states_seen);
 | 
			
		||||
        break;
 | 
			
		||||
| 
						 | 
				
			
			@ -826,7 +828,7 @@ int main (int argc, char **argv)
 | 
			
		|||
    print = (atoi (argv[4]) != 0);
 | 
			
		||||
 | 
			
		||||
  printf ("prng seed %u first %d count %d print %d\n", seed, first, count, print);
 | 
			
		||||
  init_genrand (seed);
 | 
			
		||||
  ddsrt_prng_init_simple (&prng, seed);
 | 
			
		||||
 | 
			
		||||
  memset (rres_mseq, 0, sizeof (rres_mseq));
 | 
			
		||||
  for (size_t i = 0; i < sizeof (rres_iseq) / sizeof(rres_iseq[0]); i++)
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
		Loading…
	
	Add table
		Add a link
		
	
		Reference in a new issue