`steady_clock`과 `system_clock` 차이는?

`steady_clock`은 단조 증가를 보장해 경과 시간·타임아웃 측정에 쓰고, `system_clock`은 실제 시각(UTC 기준) 표현에 씁니다. NTP 조정에 시계가 뒤로 갈 수 있으면 후자는 간격 측정에 부적합할 수 있습니다.

벤치마크에는 무엇을 쓰나요?

CPU 사이클이 아니라면 `steady_clock` 또는 고해상도 타이머를 쓰고, 여러 번 반복해 분산을 보는 편이 안전합니다.

`now()` 두 번 빼면 항상 정확한가요?

대략적인 경과는 맞지만 최적화·인라인에 따라 미세한 오차가 있습니다. 나노초 단위 미세 벤치마크는 전용 API를 검토하세요.

윈·리눅스에서 해상도가 다른데 문제되나요?

구현에 따라 다릅니다. 크로스 플랫폼 비교는 같은 빌드에서 상대 측정을 하고, 절대값은 문서를 확인하세요.

C++ steady_clock | "안정 시계" 가이드

2026년 3월 12일 · 17분 읽기 · 수정 2026년 3월 30일 중급 튜토리얼

이 글의 핵심

C++ steady_clock에 대해 정리한 개발 블로그 글입니다. auto start = std::chrono::steady_clock::now();

steady_clock이란?

단조 증가하는 시계 (C++11)

#include <chrono>

auto start = std::chrono::steady_clock::now();
// 작업
auto end = std::chrono::steady_clock::now();
auto elapsed = end - start;

특징

// 단조 증가 보장
// - 시스템 시간 변경 영향 없음
// - 항상 증가
// - 성능 측정에 적합

std::chrono::steady_clock::is_steady;  // true

실전 예시

예시 1: 벤치마크

template<typename Func>
auto benchmark(Func f) {
    auto start = std::chrono::steady_clock::now();
    
    f();
    
    auto end = std::chrono::steady_clock::now();
    return std::chrono::duration_cast<std::chrono::microseconds>(
        end - start
    );
}

int main() {
    auto duration = benchmark( {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    });
    
    std::cout << "실행 시간: " << duration.count() << "μs" << std::endl;
}

예시 2: 타이머 클래스

class Timer {
    std::chrono::steady_clock::time_point start;
    
public:
    Timer() : start(std::chrono::steady_clock::now()) {}
    
    void reset() {
        start = std::chrono::steady_clock::now();
    }
    
    auto elapsed() const {
        auto end = std::chrono::steady_clock::now();
        return std::chrono::duration_cast<std::chrono::milliseconds>(
            end - start
        );
    }
};

int main() {
    Timer timer;
    
    // 작업
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    std::cout << "경과: " << timer.elapsed().count() << "ms" << std::endl;
}

예시 3: 타임아웃

bool waitWithTimeout(std::chrono::milliseconds timeout) {
    auto start = std::chrono::steady_clock::now();
    
    while (true) {
        if (isReady()) {
            return true;
        }
        
        auto now = std::chrono::steady_clock::now();
        if (now - start >= timeout) {
            return false;  // 타임아웃
        }
        
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

예시 4: 성능 비교

void comparePerformance() {
    auto duration1 = benchmark(algorithm1);
    auto duration2 = benchmark(algorithm2);
    
    if (duration1 < duration2) {
        std::cout << "algorithm1이 더 빠름" << std::endl;
    }
    
    auto diff = duration2 - duration1;
    std::cout << "차이: " << diff.count() << "μs" << std::endl;
}

system_clock vs steady_clock

// system_clock: 시스템 시간 (변경 가능)
auto sys = std::chrono::system_clock::now();

// steady_clock: 단조 증가 (변경 불가)
auto steady = std::chrono::steady_clock::now();

// 성능 측정: steady_clock 사용

자주 발생하는 문제

문제 1: 시계 선택

// ❌ system_clock (시간 변경 영향)
auto start = std::chrono::system_clock::now();
// 시스템 시간 1시간 뒤로
auto end = std::chrono::system_clock::now();
// 음수 duration

// ✅ steady_clock
auto start = std::chrono::steady_clock::now();
auto end = std::chrono::steady_clock::now();
// 항상 양수

문제 2: 정밀도

// steady_clock 정밀도는 플랫폼 의존
using period = std::chrono::steady_clock::period;
std::cout << "정밀도: " << period::num << "/" << period::den << "s" << std::endl;

문제 3: 오버헤드

// 시계 호출 자체도 시간 소요
auto start = std::chrono::steady_clock::now();
auto end = std::chrono::steady_clock::now();

auto overhead = end - start;
std::cout << "오버헤드: " << overhead.count() << "ns" << std::endl;

문제 4: 긴 측정

// 매우 긴 측정 시 오버플로우 주의
auto start = std::chrono::steady_clock::now();

// 며칠 후
auto end = std::chrono::steady_clock::now();

// duration 타입 확인

활용 패턴

// 1. 벤치마크
auto duration = benchmark(func);

// 2. 타임아웃
bool success = waitWithTimeout(1000ms);

// 3. 성능 비교
compareAlgorithms();

// 4. 프로파일링
profileFunction();

steady_clock vs system_clock vs high_resolution_clock

C++11 chrono에는 대표적으로 세 시계가 있습니다. 이름만 보고 “항상 high_resolution이 가장 좋다”고 고르면 오히려 이식성이 나빠질 수 있습니다.

시계	단조 증가(steady)	의미 있는 절대 시각	일반적 용도
`steady_clock`	보장 (`is_steady == true`)	epoch는 구현 정의, “몇 시”로 쓰기 어려움	경과 시간, 데드라인, 타임아웃, 벤치마크
`system_clock`	아님 (NTP·수동 조정 영향)	wall-clock, `to_time_t` 등과 연동	로그 시각, 파일·DB 타임스탬프, 만료일(캘린더 의미)
`high_resolution_clock`	구현에 따라 다름	종종 `steady_clock` 또는 `system_clock`의 별칭	짧은 구간 측정(단, 이식성 주의)

high_resolution_clock 주의: 표준은 이 타입이 steady_clock이나 system_clock의 typedef일 수 있다고만 규정합니다. 따라서 절대 시각이 필요하면 system_clock, **경과·타임아웃이면 steady_clock**을 직접 쓰는 편이 예측 가능합니다. high_resolution_clock은 “이식성보다 로컬 마이크로벤치”에 가깝습니다.

#include <chrono>
#include <iostream>

int main() {
    using namespace std::chrono;
    std::cout << std::boolalpha;
    std::cout << "steady_clock::is_steady: " << steady_clock::is_steady << '\n';
    std::cout << "system_clock::is_steady: " << system_clock::is_steady << '\n';
    std::cout << "high_resolution_clock::is_steady: " << high_resolution_clock::is_steady << '\n';
}

시간 측정 패턴

한 구간 측정: auto t0 = steady_clock::now(); … 작업 … auto dt = steady_clock::now() - t0;
내부 연산은 원래 duration 타입을 유지하고, 표시할 때만 duration_cast하는 편이 누적 오차를 줄이는 데 유리합니다.
여러 구간 누적: 구간마다 duration을 더하거나 time_point 차이를 합산합니다.
최소 오버헤드 측정: 아주 짧은 코드는 now() 두 번만으로도 수백 나노초가 나올 수 있어, 측정 대비 오버헤드를 빼거나(캘리브레이션), 반복 실행 후 평균·분위수를 쓰는 것이 일반적입니다.
sleep과 혼합: sleep_for는 “최소”만 보장하므로, 실제 경과는 항상 steady_clock으로 재는 것이 맞습니다.

auto t0 = std::chrono::steady_clock::now();
do_work();
auto t1 = std::chrono::steady_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0);

벤치마킹 활용

마이크로벤치에서는 다음을 함께 고려합니다.

워밍업: 캐시·할당기 상태가 첫 실행과 다를 수 있어, 몇 번 버린 뒤 측정합니다.
반복: 한 번보다 N회 평균·중앙값이 안정적입니다. 노이즈가 크면 고정밀 타이머 + 통계를 병행합니다.
최적화 방지: 컴파일러가 결과를 버리지 않게 벤치마크 라이브러리의 DoNotOptimize 패턴을 쓰기도 합니다(실무에서는 Google Benchmark 등 권장).
시계 선택: 경과 시간은 steady_clock. 결과를 “현재 시각”과 함께 로그에 남기려면 로그용으로만 system_clock을 쓰고, 측정 구간은 steady_clock으로 분리합니다.

위 파일의 benchmark 템플릿은 개념 설명용이며, 제품 코드에서는 외부 벤치마크 프레임워크와 프로파일러를 함께 쓰는 것이 좋습니다.

실전: 타임아웃 구현 (심화)

폴링 루프에서 타임아웃을 줄 때는 시작 시각 + 한도보다 deadline 시각을 두는 편이 읽기 쉽습니다.

#include <chrono>
#include <thread>

bool wait_until(std::chrono::steady_clock::time_point deadline,
                auto pred, std::chrono::milliseconds poll) {
    while (std::chrono::steady_clock::now() < deadline) {
        if (pred()) return true;
        std::this_thread::sleep_for(poll);
    }
    return false;
}

조건 변수·future: 스레드 동기화가 있으면 wait_for / wait_until이 CPU를 덜 쓰고 깨우기도 정확합니다. 폴링은 구현이 단순할 때만 사용합니다.
남은 시간: deadline - steady_clock::now()가 음수면 이미 만료입니다. duration_cast 전에 부호를 확인하거나 0으로 클램프합니다.

플랫폼별 차이

Linux: steady_clock은 보통 CLOCK_MONOTONIC 계열로, 시스템 시간 조정과 무관합니다. 해상도는 steady_clock::period로 확인합니다.
Windows: 구현은 MSVC/MinGW에 따라 다르지만, 표준 의미(단조 증가)는 동일하게 기대합니다. 고해상도 카운터를 쓰는 경우가 많습니다.
macOS/iOS: steady_clock은 일반적으로 단조 증가를 만족합니다. high_resolution_clock이 내부적으로 동일 시계를 가리키는 경우가 많습니다.
임베디드/RTOS: 틱 수가 낮으면 짧은 구간 측정에서 양자화 오차가 커질 수 있습니다. period::num/den과 실제 측정 오차를 한 번 확인하는 것이 좋습니다.
긴 가동 시간: 극단적으로 긴 업타임에서 카운터 비트 폭이 이론적 한계에 가까우면(드묾) 오버플로를 염두에 두되, 일반 데스크톱/서버에서는 duration 타입이 넉넉한 경우가 많습니다.

한 줄 요약: 절대 시각은 system_clock, 지속 시간과 타임아웃은 steady_clock, 이름만 보고 고르지 말고 high_resolution_clock의 is_steady와 구현 관계를 확인하세요.

FAQ

Q1: steady_clock은?

A: 단조 증가 시계.

Q2: system_clock과 차이?

steady: 단조 증가
system: 시스템 시간

Q3: 성능 측정?

A: steady_clock 권장.

Q4: 정밀도?

A: 플랫폼 의존. 나노초 수준.

Q5: 오버헤드?

A: 나노초 수준. 무시 가능.

Q6: steady_clock 학습 리소스는?

“C++ Primer”
“Effective Modern C++”
cppreference.com

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

C++ Chrono | “시간 라이브러리” 가이드
C++ Chrono | “시간” 라이브러리 완벽 가이드
C++ time_point | “시간 지점” 가이드

C++ Chrono 완벽 가이드 |
C++ Chrono 상세 가이드 |
C++ duration |
C++ ratio |
C++ 스톱워치와 벤치마크 | chrono으로 실행 시간 측정하기