Abseil Random Distributions — Uniform·Exponential

1
absl::BitGen bg;
2

3
int    u  = absl::Uniform(bg, 0, 10);
4
double g  = absl::Gaussian<double>(bg, 0.0, 1.0);
5
double e  = absl::Exponential<double>(bg, 1.0);
6
int    p  = absl::Poisson<int>(bg, 5.0);
7
bool   b  = absl::Bernoulli(bg, 0.5);
8
double z  = absl::Zipf<double>(bg, 100, 2.0);
9
double lr = absl::LogUniform<double>(bg, 1, 1000);

1
// 기본 — [a, b) (정수·실수 동일)
2
int i = absl::Uniform(bg, 0, 100);
3

4
// interval tag 명시
5
int j = absl::Uniform(absl::IntervalClosed, bg, 1, 6);     // [1, 6]
6
int k = absl::Uniform(absl::IntervalOpen, bg, 0, 10);      // (0, 10)
7
int l = absl::Uniform(absl::IntervalOpenClosed, bg, 0, 9); // (0, 9]
8

9
// 단일 인자 — [0, n) 정수
10
int n = absl::Uniform(bg, 100);

1
auto x = absl::Uniform(bg, 0, 10);                // int
2
auto y = absl::Uniform(bg, 0.0, 1.0);             // double
3
auto z = absl::Uniform<int64_t>(bg, 0, 1'000'000); // 명시 타입

1
double standard = absl::Gaussian<double>(bg, 0.0, 1.0);
2
double iq       = absl::Gaussian<double>(bg, 100.0, 15.0);

1
// 평균 = 1/lambda
2
double dt = absl::Exponential<double>(bg, 0.5);   // 평균 2.0

1
int requests = absl::Poisson<int>(bg, 100.0);  // 평균 100건/유닛

1
bool heads = absl::Bernoulli(bg, 0.5);    // 50%
2
bool rare  = absl::Bernoulli(bg, 0.01);   // 1% 확률

1
// 1% 샘플링 로깅
2
if (absl::Bernoulli(bg, 0.01)) {
3
    LOG(INFO) << expensive_dump;
4
}

1
// k ∈ [1, n], 가중치 ∝ 1 / k^s
2
int k = absl::Zipf<int>(bg, 1000, 1.0);   // 캐시 키 핫스팟 모방

1
// [1, 1000] 범위에서 자릿수 균등 (1자리, 2자리, 3자리가 같은 확률)
2
int latency = absl::LogUniform<int>(bg, 1, 1000);

1
double q = absl::Beta<double>(bg, alpha, beta);

1
struct Request {
2
    absl::Time arrival;
3
    int size_bytes;
4
    int latency_budget_ms;
5
};
6

7
std::vector<Request> GenerateLoad(absl::BitGen& bg,
8
                                  absl::Duration window,
9
                                  double qps_mean) {
10
    std::vector<Request> out;
11
    absl::Time t = absl::Now();
12
    absl::Time end = t + window;
13

14
    while (t < end) {
15
        Request r;
16
        r.arrival = t;
17
        r.size_bytes = absl::LogUniform<int>(bg, 64, 1 << 20);
18
        r.latency_budget_ms = absl::Gaussian<int>(bg, 100, 30);
19
        out.push_back(r);
20

21
        // 다음 도착까지 Exponential 간격
22
        double dt = absl::Exponential<double>(bg, qps_mean);
23
        t += absl::Microseconds(static_cast<int64_t>(dt * 1e6));
24
    }
25
    return out;
26
}

1
// 회피 — std 분포 객체를 매번 생성
2
for (int i = 0; i < n; ++i) {
3
    std::normal_distribution<> dist(0, 1);   // ❌ 매번 객체 생성
4
    out[i] = dist(gen);
5
}
6

7
// Good — absl은 stateless
8
for (int i = 0; i < n; ++i) {
9
    out[i] = absl::Gaussian<double>(bg, 0, 1);
10
}

1
// 회피 — 잘못된 interval 가정
2
int dice = absl::Uniform(bg, 1, 6);   // ❌ 1..5만 나옴
3

4
// Good
5
int dice = absl::Uniform(absl::IntervalClosed, bg, 1, 6);