C++ 난수 생성 std::random + 생성 시간 측정하는 std::chrono 라이브러리

<random>

#include <iostream>
#include <random>

int main() {
  // 시드값을 얻기 위한 random_device 생성.
  std::random_device rd;

  // random_device 를 통해 난수 생성 엔진을 초기화 한다.
  std::mt19937 gen(rd());
  // 또는 미리 범위를 지정 할 수가 있음
  // std::mt19937 gen(1234);

  // 0 부터 99 까지 균등하게 나타나는 난수열을 생성하기 위해 균등 분포 정의.
  std::uniform_int_distribution<int> dis(0, 99);

  for (int i = 0; i < 5; i++) {
    std::cout << "난수 : " << dis(gen) << std::endl;
  }
}

난수 : 77
난수 : 11
난수 : 45
난수 : 72
난수 : 3

C++ 에서는 좀더 양질의 시드값을 얻기 위해 random_device 라는 것을 제공한다. 대부분의 운영체제에는 진짜 난수값들을 얻어낼 수 있는 여러가지 방식들을 제공하고 있다. 예를 들어서 리눅스의 경우 /dev/random 나 /dev/urandom 을 통해서 난수값을 얻을 수 있다. 이 난수값은, 이전에 우리가 이야기 하였던 무슨 수학적 알고리즘을 통해 생성되는 가짜 난수가 아니라 정말로 컴퓨터가 실행하면서 마주치는 무작위적인 요소들 (예를 들어 장치 드라이버들의 noise) 을 기반으로한 진정한 난수를 제공한다.

 

random_device 를 이용하면 운영체제 단에서 제공하는 진짜 난수를 사용할 수 있다. 다만 진짜 난수의 경우 컴퓨터가 주변의 환경과 무작위적으로 상호작용하면서 만들어지는 것이기 때문에 의사 난수보다 난수를 생성하는 속도가 매우 느리다. 따라서 시드값처럼 난수 엔진을 초기화 하는데 사용하고, 그 이후의 난수열은 난수 엔진으로 생성하는 것이 적합하다.

 

std::mt19937 는 C++ <random> 라이브러리에서 제공하는 난수 생성 엔진 중 하나로, 메르센 트위스터 라는 알고리즘을 사용한다. 이 알고리즘은 기존에 rand 가 사용하였던 선형 합동 방식 보다 좀 더 양질의 난수열을 생성한다고 알려져있다. 무엇보다도 생성되는 난수들 간의 상관관계가 매우 작기 때문에 여러 시뮬레이션에서 사용할 수 있다. 참고적으로 <random> 라이브러리에는 위 메르센 트위스터 기반 엔진 말고도 기존의 rand 와 같이 선형 합동 알고리즘을 사용한 minstd_rand 외 여러가지 엔진들이 정의되어 있다. 물론 mt19937 이 훌륭한 난수를 생성하기에는 적합하지만 생각보다 객체 크기가 커서 (2KB 이상) 메모리가 부족한 시스템에서는 오히려 minstd_rand 가 적합할 수 있다.

mt19937 를 생성한 이후에 난수를 생성하는 작업은 매우 빠르다.

 

이처럼 난수 생성 엔진을 만들었지만 아직 바로 난수를 생성할 수 있는 것은 아니다. C++ 의 경우 어디에서 수들을 뽑아낼지 알려주는 분포(distribution) 을 정의해야 한다. 앞서 우리의 경우 0 부터 99 까지 균등한 확률로 정수를 뽑아낼려면 아래와 같이 균등 분포 (Uniform distribution) 객체를 정의해야 한다.

 

<random> 라이브러리에서는 균등 분포 말고도 여러가지 분포들을 제공하고 있다. 그 중 가장 많이 쓰이는 정규 분포 (Normal distribution) 만 간단히 살펴본다. 전체 목록

-4  1
-3  38
-2 ****** 638
-1 ************************ 2407
 0 ************************************** 3821
 1 ************************ 2429
 2 ***** 595
 3  70
 4  1

<chrono>

<chrono> 에서는 여러가지 종류의 시계들을 지원하고 있다. 예를 들어서 일반적 상황에서 현재 컴퓨터 상 시간을 얻어 오기 위해서는 std::system_clock 을 사용하면 되고, 좀더 정밀한 시간 계산이 필요한 경우 (예를 들어 프로그램 성능을 측정하고 싶을 때) std::high_resolution_clock 을 사용하면 된다.

 

이들 객체의 이름이 시계이기는 하지만 실제 시계 처럼 지금 딱 몇 시 이렇게 이야기 해주는 것이 아니다. 그 대신에, 지정된 시점으로 부터 몇 번의 틱(tick)이 발생 하였는지 알려주는 time_stamp 객체 를 리턴한다. 예를 들어서 std::system_clock 의 경우 1970 년 1월 1일 부터 현재 까지 발생한 틱의 횟수를 리턴한다.

이를 흔히 유닉스 타임(Unix time) 이라 부른다.

쉽게 말해 time_stamp 객체는 clock 의 시작점과 현재 시간의 duration 을 보관하는 객체이다. 여기서 틱이라고 하면 시계의 초침이 한 번 똑딱 거리는 것이라 생각하면 된다. 컴퓨터의 경우도 내부에 시계가 있어서 특정 진동수로 똑딱 거리게 된다. 각 시계 마다 정밀도가 다르기 때문에 각 clock 에서 얻어지는 tick 값 자체는 조금씩 다르다. 예를 들어서 system_clock 이 1 초에 1 tick 이라면, high_resolution_clock 의 경우 0.00000001 초 마다 1 tick 움직일 수 있다.

 

아래 코드는 난수를 생성 속도를 측정한다.

#include <chrono>
#include <iomanip>
#include <iostream>
#include <random>
#include <vector>

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());

  std::uniform_int_distribution<> dist(0, 1000);

  for (int total = 1; total <= 1000000; total *= 10) {
    std::vector<int> random_numbers;
    random_numbers.reserve(total);

    std::chrono::time_point<std::chrono::high_resolution_clock> start =
        std::chrono::high_resolution_clock::now();

    for (int i = 0; i < total; i++) {
      random_numbers.push_back(dist(gen));
    }

    std::chrono::time_point<std::chrono::high_resolution_clock> end =
        std::chrono::high_resolution_clock::now();

    // C++ 17 이전
    auto diff = end - start;

    // C++ 17 이후
    // std::chrono::duration diff = end - start; 

    std::cout << std::setw(7) << total
              << "개 난수 생성 시 틱 횟수 : " << diff.count() << std::endl;
  }
}

      1개 난수 생성 시 틱 횟수 : 535
     10개 난수 생성 시 틱 횟수 : 1370
    100개 난수 생성 시 틱 횟수 : 11354
   1000개 난수 생성 시 틱 횟수 : 110219
  10000개 난수 생성 시 틱 횟수 : 1145811
 100000개 난수 생성 시 틱 횟수 : 11040923
1000000개 난수 생성 시 틱 횟수 : 99170277

std::chrono::time_point<std::chrono::high_resolution_clock> start =
  std::chrono::high_resolution_clock::now();

먼저 high_resolution_clock 으로 부터 현재의 time_point 를 얻어오는 코드부터 살펴보자 chrono 라이브러리의 경우 다른 표준 라이브러리와는 다르게 객체들이 std::chrono 이름 공간 안에 정의되어 있다. 따라서 high_resolution_clock 를 쓰기 위해서는 std::high_resolution_clock 가 아니라 std::chrono::high_resolution_clock 와 같이 적어야 한다. 이들 clock 에는 현재의 time_point 를 리턴하는 static 함수인 now 가 정의되어 있다. 이 now() 를 호출하면 위와 같이 해당 clock 에 맞는 time_point 객체를 리턴한다. 우리의 경우 high_resolution_clock::now() 를 호출하였으으므로, std::chrono::time_point<ch::high_resolution_clock> 를 리턴한다. time_point 가 clock 을 왜 템플릿 인자로 가지는지는 앞서도 설명하였듯이 clock 마다 1 초에 발생하는 틱 횟수가 모두 다르기 때문에 나중에 실제 시간으로 변환 시에 어떤 clock 을 사용했는지에 대한 정보가 필요하기 때문이다.

auto diff = end - start;

난수 생성이 끝나면 end 에 끝나는 시간을 또 받아서 그 차이를 계산해야 한다. 위와 같이 두 time_stamp 를 빼게 된다면 duration 객체를 리턴한다.

 

참고로 C++ 17 이전에서는 end - start 가 리턴하는 duration 객체의 템플릿 인자를 전달해야 한다. 따라서 굳이 duration 의 템플릿 인자들을 지정하기 보다는 속시원하게 그냥 auto diff = end - start 로 하는게 낫다.

std::cout << std::setw(7) << total
          << "개 난수 생성 시 틱 횟수 : " << diff.count() << std::endl;

duration 에는 count 라는 멤버 함수가 정의되어 있는데 이는 해당 시간 차이 동안 몇 번의 틱이 발생하였는지를 알려준다. 하지만 우리에게 좀 더 의미 있는 정보는 틱이 아니라 실제 시간으로 얼마나 걸렸는지 알아내는 것인데 이를 위해선 duration_cast 를 사용해야 한다.

#include <chrono>
#include <iomanip>
#include <iostream>
#include <random>
#include <vector>

namespace ch = std::chrono;

int main() {
  std::random_device rd;
  std::mt19937 gen(rd());

  std::uniform_int_distribution<> dist(0, 1000);

  for (int total = 1; total <= 1000000; total *= 10) {
    std::vector<int> random_numbers;
    random_numbers.reserve(total);

    ch::time_point<ch::high_resolution_clock> start =
        ch::high_resolution_clock::now();

    for (int i = 0; i < total; i++) {
      random_numbers.push_back(dist(gen));
    }

    ch::time_point<ch::high_resolution_clock> end =
        ch::high_resolution_clock::now();

    auto diff = end - start;
    std::cout << std::setw(7) << total << "개 난수 생성 시 걸리는 시간: "
              << ch::duration_cast<ch::microseconds>(diff).count() << "us"
              << std::endl;
  }
}

      1개 난수 생성 시 걸리는 시간: 0us
     10개 난수 생성 시 걸리는 시간: 1us
    100개 난수 생성 시 걸리는 시간: 10us
   1000개 난수 생성 시 걸리는 시간: 101us
  10000개 난수 생성 시 걸리는 시간: 1033us
 100000개 난수 생성 시 걸리는 시간: 10702us
1000000개 난수 생성 시 걸리는 시간: 98950us

ch::duration_cast<ch::microseconds>(diff).count()

duration_cast 는 임의의 duration 객체를 받아서 우리가 원하는 duration 으로 캐스팅 할 수 있다. std::chrono::microseconds 는 <chrono> 에 미리 정의되어 있는 duration 객체 중 하나로, 1 초에 10^6106 번 틱을 하게 된다. 따라서 microseconds 로 캐스팅 한뒤에 리턴하는 count 값은 해당 duration 이 몇 마이크로초 인지를 나타내는 것이다. 1000000 개의 난수를 생성하는데 불과 98950 마이크로초, 대량 98 밀리초 정도 걸린다고 나왔다. 

 

출처 : 씹어먹는 C++ - <17 - 3. 난수 생성(<random>)과 시간 관련 라이브러리(<chrono>) 소개> (modoocode.com)