Question

I ve tried for hours to find the implementation of rand() function used in gcc... It would be much appreciated if someone could reference me to the file containing it s implementation or website with the implementation.

这样,哪一部名录(如果是这样的话,使用乌兰巴托语,则包含对索引编制者的标准图书馆执行?

Answer 1

>。 code__random>>/a>,其中大多称为

请注意,上述功能名称与2.28版的平衡源存放处有超链接。

glibc随机图书馆支持两种发电机:一个简单的。可以使用线性反馈转换登记册生成器(见 unsafe_state.rand_type <<<>>a>。

Answer 2

您将发现海合会在项目中使用的C图书馆。

您可以下载,请查阅rand(> 执行。功能定义的来源通常没有安装在含水层分配上。只有我猜测你已经知道的头号档案通常存放在<代码>/usr/include目录上。

如果你熟悉<GIT源代码管理,你可以:

$ git clone git://sourceware.org/git/glibc.git

• 获取GLIBC源代码。

Answer 3

这些档案可通过FTP查阅。我发现,在<代码>stdlib上使用的<>,>更多,即[glibc]/code>。 2.32版本(glibc-2.32.tar.gz)从,stdlib/ .domc/file>解释说,使用的是一条线。复印机还有<代码>rand.c和rand_r.c,这些代码可以显示你更多来源代码。 <代码>stdlib.h 载于同一文件夹中的数值将显示用于诸如RAND_等宏观数值。



/* An improved random number generation package.  In addition to the
standard    rand()/srand() like interface, this package also has a
special state info    interface.  The initstate() routine is called
with a seed, an array of    bytes, and a count of how many bytes are
being passed in; this array is    then initialized to contain
information for random number generation with    that much state
information.  Good sizes for the amount of state    information are
32, 64, 128, and 256 bytes.  The state can be switched by    calling
the setstate() function with the same array as was initialized    with
initstate().  By default, the package runs with 128 bytes of state

information and generates far better random numbers than a linear

congruential generator.  If the amount of state information is less
than    32 bytes, a simple linear congruential R.N.G. is used.
Internally, the    state information is treated as an array of longs;
the zeroth element of    the array is the type of R.N.G. being used
(small integer); the remainder    of the array is the state
information for the R.N.G.  Thus, 32 bytes of    state information
will give 7 longs worth of state information, which will    allow a
degree seven polynomial.  (Note: The zeroth word of state

information also has some other information stored in it; see setstate
for details).  The random number generation technique is a linear
feedback    shift register approach, employing trinomials (since there
are fewer terms    to sum up that way).  In this approach, the least
significant bit of all    the numbers in the state table will act as a
linear feedback shift register,    and will have period 2^deg - 1
(where deg is the degree of the polynomial    being used, assuming
that the polynomial is irreducible and primitive).    The higher order
bits will have longer periods, since their values are    also
influenced by pseudo-random carries out of the lower bits.  The

total period of the generator is approximately deg*(2deg - 1); thus
doubling the amount of state information has a vast influence on the

period of the generator.  Note: The deg*(2deg - 1) is an
approximation    only good for large deg, when the period of the shift
register is the    dominant factor.  With deg equal to seven, the
period is actually much    longer than the 7*(2**7 - 1) predicted by
this formula.  */

Answer 4

http://sourceware.org/git/glibc.git。由此可见,执行工作在随机生成的锁下,因此,在温热道路的多面环境中利用这种执行是不正确的。

/* If we are using the trivial TYPE_0 R.N.G., just do the old linear
   congruential bit.  Otherwise, we do our fancy trinomial stuff, which is the
   same in all the other cases due to all the global variables that have been
   set up.  The basic operation is to add the number at the rear pointer into
   the one at the front pointer.  Then both pointers are advanced to the next
   location cyclically in the table.  The value returned is the sum generated,
   reduced to 31 bits by throwing away the "least random" low bit.
   Note: The code takes advantage of the fact that both the front and
   rear pointers can t wrap on the same call by not testing the rear
   pointer if the front one has wrapped.  Returns a 31-bit random number.  */

long int
__random (void)
{
  int32_t retval;

  __libc_lock_lock (lock);

  (void) __random_r (&unsafe_state, &retval);

  __libc_lock_unlock (lock);

  return retval;
}

weak_alias (__random, random)

Instead, you can create thread_local instances of generators to mitigate the bottleneck:

C++:

thread_local std::mt19937 generator(42 /* seed (can be e.g. time)*/);

void thread_safe_rand(int n) {
  std::uniform_int_distribution<int> distribution(0, n-1);
  return distribution();
}

友情链接