@@ -194,22 +194,7 @@ m_bGCStatus(false),

m_ClosedSockets()

{

// Socket ID MUST start from a random value

// Note. Don't use CTimer here, because s_UDTUnited is a static instance of CUDTUnited

// with dynamic initialization (calling this constructor), while CTimer has

// a static member s_ullCPUFrequency with dynamic initialization.

// The order of initialization is not guaranteed.

timeval t;

gettimeofday(&t, 0);

srand((unsigned int)t.tv_usec);

const double rand1_0 = double(rand())/RAND_MAX;

// Motivation: in case when rand() returns the value equal to RAND_MAX,

// rand1_0 == 1, so the below formula will be

// 1 + (MAX_SOCKET_VAL-1) * 1 = 1 + MAX_SOCKET_VAL - 1 = MAX_SOCKET_VAL

// which is the highest allowed value for the socket.

m_SocketIDGenerator = 1 + int((MAX_SOCKET_VAL-1) * rand1_0);

m_SocketIDGenerator = genRandomInt(1, MAX_SOCKET_VAL);

m_SocketIDGenerator_init = m_SocketIDGenerator;

// XXX An unlikely exception thrown from the below calls

@@ -562,12 +562,6 @@ int CChannel::sendto(const sockaddr_any& addr, CPacket& packet) const

if (!packet.isControl())

{

if (dcounter == 0)

{

timeval tv;

gettimeofday(&tv, 0);

srand(tv.tv_usec & 0xFFFF);

}

++dcounter;

if (flwcounter)

@@ -581,7 +575,7 @@ int CChannel::sendto(const sockaddr_any& addr, CPacket& packet) const

if (dcounter > 8)

{

// Make a random number in the range between 8 and 24

int rnd = rand() % 16 + SRT_TEST_FAKE_LOSS;

const int rnd = srt::sync::getRandomInt(8, 24);

if (dcounter > rnd)

{

@@ -525,11 +525,9 @@ class FileCC : public SrtCongestionControlBase

m_iLastDecSeq = m_parent->sndSeqNo();

// remove global synchronization using randomization

srand(m_iLastDecSeq);

m_iDecRandom = (int)ceil(m_iAvgNAKNum * (double(rand()) / RAND_MAX));

if (m_iDecRandom < 1)

m_iDecRandom = 1;

// remove global synchronization using randomization.

m_iDecRandom = genRandomInt(1, m_iAvgNAKNum);

SRT_ASSERT(m_iDecRandom >= 1);

HLOGC(cclog.Debug, log << "FileCC: LOSS:NEW lseqno=" << lossbegin

<< ", lastsentseqno=" << m_iLastDecSeq

<< ", seqdiff=" << CSeqNo::seqoff(m_iLastDecSeq, lossbegin)

@@ -401,9 +401,7 @@ class CUDT

static int32_t generateISN()

{

using namespace srt::sync;

// Random Initial Sequence Number (normal mode)

srand((unsigned) count_microseconds(steady_clock::now().time_since_epoch()));

return (int32_t)(CSeqNo::m_iMaxSeqNo * (double(rand()) / RAND_MAX));

return genRandomInt(0, CSeqNo::m_iMaxSeqNo);

}

// For SRT_tsbpdLoop

@@ -18,11 +18,18 @@

#include "logging.h"

#include "common.h"

// HAVE_CXX11 is defined in utilities.h, included with common.h.

// The following conditional inclusion must go after common.h.

#if HAVE_CXX11

#include <random>

#endif

namespace srt_logging

{

extern Logger inlog;

}

using namespace srt_logging;

using namespace std;

namespace srt

{

@@ -267,3 +274,77 @@ bool srt::sync::CGlobEvent::waitForEvent()

return g_Sync.lock_wait_for(milliseconds_from(10));

}

////////////////////////////////////////////////////////////////////////////////

//

// Random

//

////////////////////////////////////////////////////////////////////////////////

namespace srt

{

#if HAVE_CXX11

static std::random_device& randomDevice()

{

static std::random_device s_RandomDevice;

return s_RandomDevice;

}

#elif defined(_WIN32) && defined(__MINGW32__)

static void initRandSeed()

{

const int64_t seed = sync::steady_clock::now().time_since_epoch().count();

srand((unsigned int) seed);

}

static pthread_once_t s_InitRandSeedOnce = PTHREAD_ONCE_INIT;

#else

static unsigned int genRandSeed()

{

// Duration::count() does not depend on any global objects,

// therefore it is preferred over count)microseconds(..).

const int64_t seed = sync::steady_clock::now().time_since_epoch().count();

return (unsigned int) seed;

}

static unsigned int* getRandSeed()

{

static unsigned int s_uRandSeed = genRandSeed();

return &s_uRandSeed;

}

#endif

}

int srt::sync::genRandomInt(int minVal, int maxVal)

{

// This Meyers singleton initialization is thread-safe since C++11, but is not thread-safe in C++03.

// A mutex to protect simulteneout access to the random device.

// Thread-local storage could be used here instead to store the seed / random device.

// However the generator is not used often (Initial Socket ID, Initial sequence number, FileCC),

// so sharing a single seed among threads should not impact the performance.

static sync::Mutex s_mtxRandomDevice;

sync::ScopedLock lck(s_mtxRandomDevice);

#if HAVE_CXX11

uniform_int_distribution<> dis(minVal, maxVal);

return dis(randomDevice());

#else

#if defined(__MINGW32__)

// No rand_r(..) for MinGW.

pthread_once(&s_InitRandSeedOnce, initRandSeed);

// rand() returns a pseudo-random integer in the range 0 to RAND_MAX inclusive

// (i.e., the mathematical range [0, RAND_MAX]).

// Therefore, rand_0_1 belongs to [0.0, 1.0].

const double rand_0_1 = double(rand()) / RAND_MAX;

#else // not __MINGW32__

// rand_r(..) returns a pseudo-random integer in the range 0 to RAND_MAX inclusive

// (i.e., the mathematical range [0, RAND_MAX]).

// Therefore, rand_0_1 belongs to [0.0, 1.0].

const double rand_0_1 = double(rand_r(getRandSeed())) / RAND_MAX;

#endif

// Map onto [minVal, maxVal].

// Note. The probablity to get maxVal as the result is minuscule.

const int res = minVal + static_cast<int>((maxVal - minVal) * rand_0_1);

return res;

#endif // HAVE_CXX11

}

@@ -835,6 +835,18 @@ void SetThreadLocalError(const CUDTException& e);

/// @returns CUDTException pointer

CUDTException& GetThreadLocalError();

////////////////////////////////////////////////////////////////////////////////

//

// Random distribution functions.

//

////////////////////////////////////////////////////////////////////////////////

/// Generate a uniform-distributed random integer from [minVal; maxVal].

/// If HAVE_CXX11, uses std::uniform_distribution(std::random_device).

/// @param[in] minVal minimum allowed value of the resulting random number.

/// @param[in] maxVal maximum allowed value of the resulting random number.

int genRandomInt(int minVal, int maxVal);

} // namespace sync

} // namespace srt

@@ -34,7 +34,6 @@ written by

#define ATR_UNUSED

#define ATR_DEPRECATED

#endif

#if defined(__cplusplus) && __cplusplus > 199711L

#define HAVE_CXX11 1

@@ -157,6 +157,27 @@ TEST(SyncDuration, OperatorMultIntEq)

EXPECT_EQ(count_milliseconds(a), 7000);

}

TEST(SyncRandom, GenRandomInt)

{

vector<int> mn(64);

for (int i = 0; i < 2048; ++i)

{

const int rand_val = genRandomInt(0, 63);

ASSERT_GE(rand_val, 0);

ASSERT_LE(rand_val, 63);

++mn[rand_val];

}

// Uncomment to see the distribution.

// for (size_t i = 0; i < mn.size(); ++i)

// {

// cout << i << '\t';

// for (int j=0; j<mn[i]; ++j) cout << '*';

// cout << '\n';

// }

}

/*****************************************************************************/

/*

* TimePoint tests