Mengapa rand () mengulang angka jauh lebih sering di Linux daripada Mac?

Saya menerapkan hashmap dalam C sebagai bagian dari proyek yang sedang saya kerjakan dan menggunakan sisipan acak untuk mengujinya ketika saya perhatikan bahwa rand()di Linux tampaknya mengulangi angka jauh lebih sering daripada di Mac. RAND_MAXadalah 2147483647 / 0x7FFFFFFF di kedua platform. Saya telah menguranginya menjadi program pengujian ini yang membuat array byte- RAND_MAX+1panjang, menghasilkan RAND_MAXangka acak, mencatat jika masing-masing adalah duplikat, dan memeriksanya dari daftar seperti yang terlihat.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int main() {
    size_t size = ((size_t)RAND_MAX) + 1;
    char *randoms = calloc(size, sizeof(char));
    int dups = 0;
    srand(time(0));
    for (int i = 0; i < RAND_MAX; i++) {
        int r = rand();
        if (randoms[r]) {
            // printf("duplicate at %d\n", r);
            dups++;
        }
        randoms[r] = 1;
    }
    printf("duplicates: %d\n", dups);
}

Linux secara konsisten menghasilkan sekitar 790 juta duplikat. Mac secara konsisten hanya menghasilkan satu, sehingga loop melalui setiap nomor acak yang dapat dihasilkannya hampir tanpa berulang. Adakah yang bisa menjelaskan kepada saya bagaimana ini bekerja? Saya tidak dapat mengatakan hal yang berbeda dari halaman manual, tidak bisa membedakan RNG mana yang digunakan, dan tidak dapat menemukan apa pun secara online. Terima kasih!

Meskipun pada awalnya mungkin terdengar seperti macOS rand()entah bagaimana lebih baik untuk tidak mengulangi angka, orang harus mencatat bahwa dengan jumlah angka yang dihasilkan ini diharapkan akan melihat banyak duplikat (pada kenyataannya, sekitar 790 juta, atau (2 ³¹ -1) ) / e ). Demikian juga iterasi melalui angka dalam urutan juga tidak akan menghasilkan duplikat, tetapi tidak akan dianggap sangat acak. Jadi rand()implementasi Linux dalam tes ini tidak dapat dibedakan dari sumber acak yang benar, sedangkan macOS rand()tidak.

Hal lain yang tampak mengejutkan pada pandangan pertama adalah bagaimana macOS rand()dapat mengatur untuk menghindari duplikat dengan baik. Melihat kode sumbernya , kami menemukan implementasinya sebagai berikut:

/*
 * Compute x = (7^5 * x) mod (2^31 - 1)
 * without overflowing 31 bits:
 *      (2^31 - 1) = 127773 * (7^5) + 2836
 * From "Random number generators: good ones are hard to find",
 * Park and Miller, Communications of the ACM, vol. 31, no. 10,
 * October 1988, p. 1195.
 */
    long hi, lo, x;

    /* Can't be initialized with 0, so use another value. */
    if (*ctx == 0)
        *ctx = 123459876;
    hi = *ctx / 127773;
    lo = *ctx % 127773;
    x = 16807 * lo - 2836 * hi;
    if (x < 0)
        x += 0x7fffffff;
    return ((*ctx = x) % ((unsigned long) RAND_MAX + 1));

Ini memang menghasilkan semua angka antara 1 dan RAND_MAX, termasuk, tepat sekali, sebelum urutan berulang. Karena negara berikutnya didasarkan pada perkalian, negara tidak pernah bisa nol (atau semua negara masa depan juga akan menjadi nol). Jadi angka berulang yang Anda lihat adalah yang pertama, dan nol adalah yang tidak pernah dikembalikan.

Apple telah mempromosikan penggunaan generator angka acak yang lebih baik dalam dokumentasi dan contoh-contoh mereka selama setidaknya selama macOS (atau OS X) ada, sehingga kualitasnya rand()mungkin tidak dianggap penting, dan mereka baru saja terjebak dengan salah satu dari mereka. generator pseudorandom paling sederhana yang tersedia. (Seperti yang Anda catat, mereka rand()bahkan berkomentar dengan rekomendasi untuk digunakan arc4random()sebagai gantinya.)

Pada catatan terkait, generator nomor pseudorandom paling sederhana yang dapat saya temukan yang menghasilkan hasil yang layak dalam tes acak (dan banyak lainnya) untuk keacakan adalah xorshift * :

uint64_t x = *ctx;
x ^= x >> 12;
x ^= x << 25;
x ^= x >> 27;
*ctx = x;
return (x * 0x2545F4914F6CDD1DUL) >> 33;

Implementasi ini menghasilkan hampir persis 790 juta duplikat dalam pengujian Anda.

MacOS menyediakan fungsi rand () tidak berdokumen di stdlib. Jika Anda membiarkannya tidak diunggulkan, maka nilai pertama yang dihasilkannya adalah 16807, 282475249, 1622650073, 984943658 dan 1144108930. Pencarian cepat akan menunjukkan bahwa urutan ini sesuai dengan generator nomor acak LCG yang sangat dasar yang mengulangi rumus berikut:

x _{n +1} = 7 ⁵ · x _n (mod 2 ³¹ - 1)

Karena keadaan RNG ini dijelaskan sepenuhnya oleh nilai integer 32-bit tunggal, periodenya tidak terlalu lama. Tepatnya, ia mengulangi dirinya sendiri setiap 2 ³¹ - 2 iterasi, menghasilkan setiap nilai dari 1 hingga 2 ³¹ - 2.

Saya tidak berpikir ada implementasi standar rand () untuk semua versi Linux, tetapi ada fungsi glibc rand () yang sering digunakan. Alih-alih variabel negara 32-bit tunggal, ini menggunakan kumpulan lebih dari 1000 bit, yang untuk semua maksud dan tujuan tidak akan pernah menghasilkan urutan berulang sepenuhnya. Sekali lagi, Anda mungkin dapat mengetahui versi apa yang Anda miliki dengan mencetak beberapa keluaran pertama dari RNG ini tanpa menaburinya terlebih dahulu. (Fungsi glibc rand () menghasilkan angka 1804289383, 846930886, 1681692777, 1714636915 dan 1957747793.)

Jadi alasan Anda mendapatkan lebih banyak tabrakan di Linux (dan hampir tidak ada di MacOS) adalah bahwa versi Linux rand () pada dasarnya lebih acak.

rand()didefinisikan oleh standar C, dan standar C tidak menentukan algoritma mana yang digunakan. Jelas, Apple menggunakan algoritma yang lebih rendah untuk implementasi GNU / Linux Anda: Yang Linux tidak dapat dibedakan dari sumber acak sejati dalam pengujian Anda, sedangkan implementasi Apple hanya mengacak angka-angka di sekitar.

Jika Anda menginginkan angka acak dari kualitas apa pun, gunakan PRNG yang lebih baik yang memberikan setidaknya beberapa jaminan pada kualitas nomor yang dikembalikan, atau cukup baca dari /dev/urandomatau serupa. Nanti memberi Anda nomor kualitas kriptografis, tetapi lambat. Bahkan jika terlalu lambat dengan sendirinya, /dev/urandomdapat menyediakan beberapa biji unggul untuk beberapa lainnya, PRNG lebih cepat.

Secara umum, pasangan rand / srand telah dianggap semacam usang sejak lama karena bit orde rendah menampilkan lebih sedikit keacakan daripada bit orde tinggi dalam hasil. Ini mungkin atau mungkin tidak ada hubungannya dengan hasil Anda, tetapi saya pikir ini masih merupakan kesempatan yang baik untuk diingat bahwa meskipun beberapa implementasi rand / srand sekarang lebih mutakhir, implementasi yang lebih lama bertahan dan lebih baik menggunakan secara acak (3 ). Di kotak Arch Linux saya, catatan berikut masih ada di halaman manual untuk rand (3):

  The versions of rand() and srand() in the Linux C Library use the  same
   random number generator as random(3) and srandom(3), so the lower-order
   bits should be as random as the higher-order bits.  However,  on  older
   rand()  implementations,  and  on  current implementations on different
   systems, the lower-order bits are much less random than the  higher-or-
   der bits.  Do not use this function in applications intended to be por-
   table when good randomness is needed.  (Use random(3) instead.)

Tepat di bawah itu, halaman manual sebenarnya memberikan contoh implementasi rand dan srand yang sangat pendek, sangat sederhana, tentang RNG LC paling sederhana yang pernah Anda lihat dan memiliki RAND_MAX kecil. Saya tidak berpikir mereka cocok dengan apa yang ada di perpustakaan standar C, jika mereka pernah melakukannya. Atau setidaknya saya harap tidak.

Secara umum, jika Anda akan menggunakan sesuatu dari pustaka standar, gunakan secara acak jika Anda bisa (halaman manual mencantumkannya sebagai standar POSIX kembali ke POSIX.1-2001, tetapi rand adalah cara standar kembali sebelum C bahkan distandarisasi) . Atau lebih baik lagi, pecahkan Numerical Recipes (atau cari secara online) atau Knuth dan implementasikan. Mereka sangat mudah dan Anda hanya perlu melakukannya sekali untuk memiliki tujuan umum RNG dengan atribut yang paling sering Anda butuhkan dan yang memiliki kualitas yang dikenal.