Enterprise

std::atomic hi si Test

개요

C++에서 std::atomic 변수를 여러 스레드에서 사용했을 경우 hi, si가 발생하는지 서버, 노트북(VM)에서 확인하고, 일반 변수 사용할 때, std::atomic 전역 변수 사용할 때 성능(처리 속도)를 알아 본다.
hi, si: 리눅스 top 명령으로 확인할 수 있는 CPU 항목 중 hi(hardware interrupt) si(software interrupt)를 의미합니다.
테스트를 하게 된 원인: 노트북 VM(Linux)에서 helio 테스트 시 hi, si가 상당히 발생하여 성능에 크게 영향을 미치는 것으로 파악했습니다. 소스의 어느 부분(함수)에서 발생하는지 확인하려고 테스트를 진행했습니다.
테스트 결과: std::atomic 변수의 경우 '서버'는 hi,si가 발생하지 않았고, '노트북'의 경우 hi가 발생했습니다.
std::atomic 사용 시 주의사항: 서버에서 hi,si는 발생하지 않았지만, std::atomic 변수 사용 시 일반 변수에 비해 처리 속도가 매우 늦으므로 꼭 필요한 경우만 사용해야 할 것으로 판단됩니다.

테스트

📦 테스트 환경

◎ 서버

H/W Model: Dell R230
CPU: Intel(R) Xeon(R) CPU E3-1230 v6 @ 3.50GHz 4c/8t.
OS: CentOS 7.5.1804 (Core)
Linux kernel version: 3.10.0 x86_64
C compiler: g++ (GCC) 8.3.1 20190311 (Red Hat 8.3.1-3)

◎ 노트북

H/W Model: LG노트북 gram 16ZD90RU-GX56K M/D: 2023.11.
CPU: Intel i5-1335U(13th) 2.50GHz 코어:10, 논리 프로세서:12, L1 캐시: 928KB, L2: 6.5MB, L3: 12.0MB
VM: Virtualbox
Host OS: Windows 11 Pro
Guest OS: CentOS 9
Linux kernel version: 5.14.0 x86_64
C++ compiler: g++ (GCC) 11.5.0 20240719 (Red Hat 11.5.0-2)

📦 std::atomic<uint64_t> 테스트 결과 요약

테스트 방법: 스레드 당 1억회 반복: ++counter;
• thread 별 일반 변수 사용
• 전역 std::atomic 변수 사용: 각 thread는 변수를 공유하지 않음
• 전역 std::atomic 변수 사용: 여러 thread가 한 변수를 공유함
서버 테스트 결과: thread 수와 관계없이 hi, si가 발생하지 않았다.
노트북 테스트 결과: hi가 thread=5 일때 65.8%(500% 기준), 414%(1000% 기준) 발생했다. si는 발생하지 않았다.

◎ 서버

소요시간ms(1회소요시간ns(nano seconds))

구분	thread=1 (1억회)	thread=5 (5억회)	thread=10 (10억회)
thread 별 일반 변수 uint64_t counter0; atomic_int_local.cc	190ms(1.9ns)	259ms(0.52ns)	361ms(0.36ns)
전역 std::atomic<> 변수 각 thread는 변수를 공유하지 않음 atomic_int_thread.cc	668ms(6.68ns)	7,546ms(15.09ns)	15,883ms(15.88ns)
전역 std::atomic<> 변수 여러 thread가 한 변수를 공유함 atomic_int_global.cc	658ms(6.58ns)	8,619ms(17.24ns)	18,750ms(18.75ns)

◎ 노트북

구분	thread=1 (1억회)	thread=5 (5억회)	thread=10 (10억회)
전역 std::atomic<> 변수 여러 thread가 한 변수를 공유함 atomic_int_global.cc	1,681ms(16.8ns)	27,344ms(54.69ns)	47,976ms(47.97ns)

구분	thread=1 (1억회)	thread=5 (5억회)	thread=10 (10억회)
컴파일 최적화 옵션 -O2 적용	1,133ms(11.3ns)	18,626ms(37.2ns)	39,990ms(39.9ns)

컴파일 최적화 옵션
- 'Debug': 기본적으로 최적화 없이 디버깅 정보를 포함 ('-O0')
- 'RelWithDebInfo': 최적화 활성화 + 디버깅 정보 포함 ('-O2')
- 'Release': 최적화 활성화 ('-O3' 또는 플랫폼에 따라 다름)
• Redis는 '-O2', Helio는 '-O3'를 적용하고 있습니다.
- Redis: make Makefile -> OPTIMIZATION?=-O2
- Helio: blaze.sh -> cmake -DCMAKE_BUILD_TYPE=$TARGET_BUILD_TYPE = Debug/Release

📦 std::atomic_flag 테스트 결과 요약

테스트 방법: 스레드 당 1억회 반복
std::atomic_flag lock; lock.test_and_set(std::memory_order_acquire);
서버 테스트 결과: thread 수와 관계없이 hi, si가 발생하지 않았다.
노트북 테스트 결과: thread=5 일때 114%(500% 기준) 발생했다. si는 발생하지 않았다.

◎ 서버

구분	thread=1 (1억회)	thread=5 (5억회)
전역 std::atomic_flag 변수	2,280ms(22.8ns)	55,322ms(110.6ns)

◎ 노트북

구분	thread=1 (1억회)	thread=5 (5억회)
전역 std::atomic_flag 변수	1,124ms(11.2ns)	109,026ms(218.1ns)

각 파일 설명

📦 일반 변수 테스트: atomic_int_local.cc

개요: 일반 변수 사용 시 성능 테스트, std::atomic 변수와 비교해서 얼마나 차이가 나는지 확인하려고 진행.
테스트 방법: 스레드별로 일반 로칼 변수 사용: uint64_t counter0 = 0;
서버 테스트 결과: hi,si가 발생하지 않는다. (노트북은 테스트하지 않았음)
컴파일: $ g++ -o atomic_int_local atomic_int_local.cc -lpthread

소스 코드

$ cat atomic_int_local.cc #include <iostream> #include <atomic> #include <thread> uint64_t limit = 100'000'000; // 1억 void increment0() { uint64_t counter0 = 0; for (uint64_t i = 0; i < limit; ++i) ++counter0; std::cout << "counter0: " << counter0 << std::endl; } void increment1() { uint64_t counter1 = 0; for (uint64_t i = 0; i < limit; ++i) ++counter1; std::cout << "counter1: " << counter1 << std::endl; } void increment2() { uint64_t counter2 = 0; for (uint64_t i = 0; i < limit; ++i) ++counter2; std::cout << "counter2: " << counter2 << std::endl; } void increment3() { uint64_t counter3 = 0; for (uint64_t i = 0; i < limit; ++i) ++counter3; std::cout << "counter3: " << counter3 << std::endl; } void increment4() { uint64_t counter4 = 0; for (uint64_t i = 0; i < limit; ++i) ++counter4; std::cout << "counter4: " << counter4 << std::endl; } void increment5() { uint64_t counter5 = 0; for (uint64_t i = 0; i < limit; ++i) ++counter5; std::cout << "counter5: " << counter5 << std::endl; } void increment6() { uint64_t counter6 = 0; for (uint64_t i = 0; i < limit; ++i) ++counter6; std::cout << "counter6: " << counter6 << std::endl; } void increment7() { uint64_t counter7 = 0; for (uint64_t i = 0; i < limit; ++i) ++counter7; std::cout << "counter7: " << counter7 << std::endl; } void increment8() { uint64_t counter8 = 0; for (uint64_t i = 0; i < limit; ++i) ++counter8; std::cout << "counter8: " << counter8 << std::endl; } void increment9() { uint64_t counter9 = 0; for (uint64_t i = 0; i < limit; ++i) ++counter9; std::cout << "counter9: " << counter9 << std::endl; } int main() { // 시작 시간 기록 struct timespec start, end; // 나노초 단위 clock_gettime(CLOCK_MONOTONIC, &start); // 두 개의 스레드를 생성하여 증가와 감소를 수행 std::thread t0(increment0); std::thread t1(increment1); std::thread t2(increment2); std::thread t3(increment3); std::thread t4(increment4); std::thread t5(increment5); std::thread t6(increment6); std::thread t7(increment7); std::thread t8(increment8); std::thread t9(increment9); // 스레드가 종료될 때까지 기다림 t0.join(); t1.join(); t2.join(); t3.join(); t4.join(); t5.join(); t6.join(); t7.join(); t8.join(); t9.join(); // 최종 값 출력 //std::cout << "Final counter value: " << counter1 << std::endl; // 종료 시간 기록 clock_gettime(CLOCK_MONOTONIC, &end); // 소요 시간 계산 long seconds = end.tv_sec - start.tv_sec; long nanoseconds = end.tv_nsec - start.tv_nsec; long milliseconds = (seconds * 1000) + (nanoseconds / 1000000); printf("Elapsed time: %ld milliseconds\n", milliseconds); return 0; }

서버 테스트 결과: 소요시간 thread=1,5,10

** std:cout은 소요시간(성능)에 영향이 없다. 1ms도 차이나지 않는다.
** thread=1 보다 소요시간이 136% 더 걸렸으나 이것은 스레드 생성시간이 더 걸린것으로 보인다.

회	thread=1	thread=5	thread=10
1회	190ms	261ms	373ms
2회	191ms	260ms	359ms
3회	190ms	256ms	358ms
평균(avg)	190ms	259ms (136%)	363ms (191%)

📦 thread std::atomic 변수 테스트: atomic_int_thread.cc

테스트 방법: 한 스레드에서 한 std::atomic 변수만 사용 시 성능 테스트
서버 테스트 결과: hi,si가 발생하지 않는다.
컴파일: $ g++ -o atomic_int_thread atomic_int_thread.cc -lpthread

소스 코드

$ cat atomic_int_thread.cc #include <iostream> #include <atomic> #include <thread> std::atomic<uint64_t> counter0(0); std::atomic<uint64_t> counter1(0); std::atomic<uint64_t> counter2(0); std::atomic<uint64_t> counter3(0); std::atomic<uint64_t> counter4(0); std::atomic<uint64_t> counter5(0); std::atomic<uint64_t> counter6(0); std::atomic<uint64_t> counter7(0); std::atomic<uint64_t> counter8(0); std::atomic<uint64_t> counter9(0); uint64_t limit = 100'000'000; // 1억 void increment0() { for (uint64_t i = 0; i < limit; ++i) ++counter0; std::cout << "counter0: " << counter0 << std::endl; } void increment1() { for (uint64_t i = 0; i < limit; ++i) ++counter1; std::cout << "counter1: " << counter1 << std::endl; } void increment2() { for (uint64_t i = 0; i < limit; ++i) ++counter2; std::cout << "counter2: " << counter2 << std::endl; } void increment3() { for (uint64_t i = 0; i < limit; ++i) ++counter3; std::cout << "counter3: " << counter3 << std::endl; } void increment4() { for (uint64_t i = 0; i < limit; ++i) ++counter4; std::cout << "counter4: " << counter4 << std::endl; } void increment5() { for (uint64_t i = 0; i < limit; ++i) ++counter5; std::cout << "counter5: " << counter5 << std::endl; } void increment6() { for (uint64_t i = 0; i < limit; ++i) ++counter6; std::cout << "counter6: " << counter6 << std::endl; } void increment7() { for (uint64_t i = 0; i < limit; ++i) ++counter7; std::cout << "counter7: " << counter7 << std::endl; } void increment8() { for (uint64_t i = 0; i < limit; ++i) ++counter8; std::cout << "counter8: " << counter8 << std::endl; } void increment9() { for (uint64_t i = 0; i < limit; ++i) ++counter9; std::cout << "counter9: " << counter9 << std::endl; } int main() { // 시작 시간 기록 struct timespec start, end; // 나노초 단위 clock_gettime(CLOCK_MONOTONIC, &start); // 두 개의 스레드를 생성하여 증가와 감소를 수행 std::thread t0(increment0); std::thread t1(increment1); std::thread t2(increment2); std::thread t3(increment3); std::thread t4(increment4); std::thread t5(increment5); std::thread t6(increment6); std::thread t7(increment7); std::thread t8(increment8); std::thread t9(increment9); // 스레드가 종료될 때까지 기다림 t0.join(); t1.join(); t2.join(); t3.join(); t4.join(); t5.join(); t6.join(); t7.join(); t8.join(); t9.join(); // 최종 값 출력 //std::cout << "Final counter value: " << counter1 << std::endl; // 종료 시간 기록 clock_gettime(CLOCK_MONOTONIC, &end); // 소요 시간 계산 long seconds = end.tv_sec - start.tv_sec; long nanoseconds = end.tv_nsec - start.tv_nsec; long milliseconds = (seconds * 1000) + (nanoseconds / 1000000); printf("Elapsed time: %ld milliseconds\n", milliseconds); return 0; }

서버 테스트 결과: 소요시간 thread=1,2,3,5,10

회	thread=1	thread=2	thread=3	thread=5	thread=10
1회	683ms	670ms	3079ms	7330ms	15822ms
2회	660ms	670ms	2707ms	7518ms	16128ms
3회	662ms	668ms	2632ms	7789ms	15699ms
평균(avg)	668ms	669ms (102%)	2,806ms (426%)	7,546ms (1147%)	15,883ms (2414%)

📦 전역 std::atomic 변수 테스트(서버): atomic_int_global.cc

개요: 여러 스레드에서 전역 std::atomic 변수 1개 사용 시 hi,si 발생 및 성능 테스트
테스트 방법: std::atomic<uint64_t> counter; 스레드별로 ++counter; --counter;
서버 테스트 결과: hi,si가 발생하지 않는다.
컴파일: g++ -o atomic_int_global atomic_int_global.cc

소스 코드

$ cat atomic_int_global.cc #include <iostream> #include <atomic> #include <thread> std::atomic<uint64_t> counter; uint64_t limit = 100'000'000; // 1억 void increment() { for (int i = 0; i < limit; ++i) { ++counter; // 원자적 증가 연산 } } void decrement() { for (int i = 0; i < limit; ++i) { --counter; // 원자적 감소 연산 } } int main() { // 시작 시간 기록 struct timespec start, end; // 나노초 단위 clock_gettime(CLOCK_MONOTONIC, &start); // 초기화 counter = 0; // 두 개의 스레드를 생성하여 증가와 감소를 수행 std::thread t0(increment); std::thread t1(decrement); std::thread t2(increment); std::thread t3(decrement); std::thread t4(increment); std::thread t5(decrement); std::thread t6(increment); std::thread t7(decrement); std::thread t8(increment); std::thread t9(decrement); // 스레드가 종료될 때까지 기다림 t0.join(); t1.join(); t2.join(); t3.join(); t4.join(); t5.join(); t6.join(); t7.join(); t8.join(); t9.join(); // 최종 값 출력 std::cout << "Final counter value: " << counter << std::endl; // 종료 시간 기록 clock_gettime(CLOCK_MONOTONIC, &end); // 소요 시간 계산 long seconds = end.tv_sec - start.tv_sec; long nanoseconds = end.tv_nsec - start.tv_nsec; long milliseconds = (seconds * 1000) + (nanoseconds / 1000000); printf("Elapsed time: %ld milliseconds\n", milliseconds); return 0; }

서버 테스트 결과: 소요시간 thread=1,2,3,4,5,10

회	thread=1	thread=2	thread=3	thread=4	thread=5	thread=10
1회	657ms	2,602ms	3,871ms	5,946ms	9,615ms	19,772ms
2회	658ms	3,269ms	5,528ms	7,876ms	8,739ms	19,734ms
3회	659ms	3,277ms	3,861ms	7,851ms	7,502ms	16,745ms
평균(avg)	658ms	3,049ms (463%)	4,420ms (672%)	7,224ms (1098%)	8,619ms (1310%)	18,750ms (2850%)

📦 전역 std::atomic 변수 테스트(노트북): atomic_int_global.cc

노트북 테스트 결과: hi가 상당히 높게 나타난다. 스레드가 많을수록 hi가 훨씬 더 높게 나타난다.
thread=5: hi+si=65% (500% 기준)
thread=10: hi+si=415% (1000% 기준)

노트북 테스트 결과: thread=5

us+sy=439%(87%), hi+si=65%(13%)
top - 15:12:26 up 50 min, 2 users, load average: 0.83, 0.47, 0.29 %Cpu0 : 88.9 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 11.1 hi, 0.0 si, 0.0 st %Cpu1 : 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st %Cpu2 : 86.1 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 13.9 hi, 0.0 si, 0.0 st %Cpu3 : 1.0 us, 1.0 sy, 0.0 ni, 97.1 id, 0.0 wa, 1.0 hi, 0.0 si, 0.0 st %Cpu4 : 88.6 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 11.4 hi, 0.0 si, 0.0 st %Cpu5 : 86.5 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 13.5 hi, 0.0 si, 0.0 st %Cpu6 : 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st %Cpu7 : 0.0 us, 0.0 sy, 0.0 ni, 99.0 id, 0.0 wa, 1.0 hi, 0.0 si, 0.0 st %Cpu8 : 86.1 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 13.9 hi, 0.0 si, 0.0 st %Cpu9 : 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st 438.2 us, 1.0 sy, 65.8 hi = 505% PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 2570 redis 20 0 46812 5188 2944 S 473.5 0.1 0:56.31 atomic_int

노트북 테스트 결과: thread=10

us+sy=584%(58%), hi+si=415%(41%) top - 15:27:22 up 1:05, 2 users, load average: 0.00, 0.02, 0.11 %Cpu0 : 57.1 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 42.9 hi, 0.0 si, 0.0 st %Cpu1 : 72.2 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 27.8 hi, 0.0 si, 0.0 st %Cpu2 : 58.1 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 41.9 hi, 0.0 si, 0.0 st %Cpu3 : 66.7 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 33.3 hi, 0.0 si, 0.0 st %Cpu4 : 64.1 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 35.9 hi, 0.0 si, 0.0 st %Cpu5 : 67.6 us, 2.9 sy, 0.0 ni, 0.0 id, 0.0 wa, 29.4 hi, 0.0 si, 0.0 st %Cpu6 : 61.5 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 38.5 hi, 0.0 si, 0.0 st %Cpu7 : 63.2 us, 2.6 sy, 0.0 ni, 0.0 id, 0.0 wa, 34.2 hi, 0.0 si, 0.0 st %Cpu8 : 64.9 us, 2.7 sy, 0.0 ni, 0.0 id, 0.0 wa, 32.4 hi, 0.0 si, 0.0 st %Cpu9 : 1.2 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 97.7 hi, 1.2 si, 0.0 st 576.6 us, 8.2 sy, 414.0 hi, 1.2 si = 1000% PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 2644 redis 20 0 87792 5192 2944 S 800.0 0.1 0:20.91 atomic_int

📦 std::atomic_flag lock 테스트

개요: 여러 스레드에서 전역 std::atomic_flag 변수 1개 사용 시 hi,si 발생 및 성능 테스트
테스트 방법: std::atomic_flag lock; lock.test_and_set() 테스트

소스 코드

#include <iostream> #include <atomic> #include <thread> std::atomic_flag lock = ATOMIC_FLAG_INIT; uint64_t limit = 100'000'000; // 1억 void lock_example(int id) { while (lock.test_and_set(std::memory_order_acquire)) { // Busy-wait } //std::cout << "Thread " << id << " has acquired the lock.\n"; //std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Simulate work lock.clear(std::memory_order_release); //std::cout << "Thread " << id << " has released the lock.\n"; } void increment() { for (int i = 0; i < limit; ++i) { lock_example(1); } } void decrement() { for (int i = 0; i < limit; ++i) { lock_example(2); } } int main() { // 시작 시간 기록 struct timespec start, end; // 나노초 단위 clock_gettime(CLOCK_MONOTONIC, &start); // 두 개의 스레드를 생성하여 증가와 감소를 수행 std::thread t0(increment); std::thread t1(decrement); std::thread t2(increment); std::thread t3(decrement); std::thread t4(increment); std::thread t5(decrement); std::thread t6(increment); std::thread t7(decrement); std::thread t8(increment); std::thread t9(decrement); // 스레드가 종료될 때까지 기다림 t0.join(); t1.join(); t2.join(); t3.join(); t4.join(); t5.join(); t6.join(); t7.join(); t8.join(); t9.join(); // 최종 값 출력 // std::cout << "Final counter value: " << counter << std::endl; // 종료 시간 기록 clock_gettime(CLOCK_MONOTONIC, &end); // 소요 시간 계산 long seconds = end.tv_sec - start.tv_sec; long nanoseconds = end.tv_nsec - start.tv_nsec; long milliseconds = (seconds * 1000) + (nanoseconds / 1000000); printf("Elapsed time: %ld milliseconds\n", milliseconds); return 0; }

◼️ 노트북 테스트 결과

노트북 테스트 결과: thread=5 테스트 시 hi+si가 26~114%(500% 기준)까지 발생했다.
컴파일: g++ -o atomic_flag atomic_flag.cc

thread=5 초반: 473.8us+1.2sy = 475%(95%) 23.3hi+2.9si = 26.2%(5%)
top - 17:42:25 up 3:20, 2 users, load average: 2.36, 3.05, 1.87 %Cpu0 : 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st %Cpu1 : 95.6 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 4.4 hi, 0.0 si, 0.0 st %Cpu2 : 97.0 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 3.0 hi, 0.0 si, 0.0 st %Cpu3 : 94.1 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 4.4 hi, 1.5 si, 0.0 st %Cpu4 : 0.0 us, 0.6 sy, 0.0 ni, 99.4 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st %Cpu5 : 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st %Cpu6 : 97.0 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 3.0 hi, 0.0 si, 0.0 st %Cpu7 : 0.0 us, 0.6 sy, 0.0 ni, 99.4 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st %Cpu8 : 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st %Cpu9 : 90.1 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 8.5 hi, 1.4 si, 0.0 st 473.8 us, 1.2 sy = 475%(95%) 23.3 hi, 2.9 si = 26.2%(5%) PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 3736 redis 20 0 46812 5188 2944 S 490.5 0.1 0:42.11 atomic_flag thread=5 중반: 373.6us+8.0sy = 381%(77%) 112.7hi+1.4si = 114%(23%) top - 17:44:07 up 3:22, 2 users, load average: 4.15, 3.50, 2.16 %Cpu0 : 0.7 us, 0.7 sy, 0.0 ni, 93.5 id, 0.0 wa, 5.0 hi, 0.0 si, 0.0 st %Cpu1 : 69.6 us, 0.0 sy, 0.0 ni, 13.9 id, 0.0 wa, 16.5 hi, 0.0 si, 0.0 st %Cpu2 : 82.1 us, 1.3 sy, 0.0 ni, 0.0 id, 0.0 wa, 16.7 hi, 0.0 si, 0.0 st %Cpu3 : 10.7 us, 0.0 sy, 0.0 ni, 80.3 id, 0.0 wa, 9.0 hi, 0.0 si, 0.0 st %Cpu4 : 82.9 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 17.1 hi, 0.0 si, 0.0 st %Cpu5 : 84.0 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 16.0 hi, 0.0 si, 0.0 st %Cpu6 : 0.0 us, 1.7 sy, 0.0 ni, 96.7 id, 0.0 wa, 1.7 hi, 0.0 si, 0.0 st %Cpu7 : 42.9 us, 2.9 sy, 0.0 ni, 37.1 id, 0.0 wa, 15.7 hi, 1.4 si, 0.0 st %Cpu8 : 0.7 us, 0.7 sy, 0.0 ni, 91.4 id, 0.0 wa, 7.1 hi, 0.0 si, 0.0 st %Cpu9 : 0.0 us, 0.7 sy, 0.0 ni, 91.4 id, 0.0 wa, 7.9 hi, 0.0 si, 0.0 st 373.6 us, 8.0 sy = 381%(77%) 112.7 hi, 1.4 si = 114%(23%) PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 3736 redis 20 0 46812 5188 2944 S 466.9 0.1 8:58.34 atomic_flag

소요시간: thread=1,2,3,4,5

회	thread=1	thread=2	thread=3	thread=4	thread=5
1회	1,119ms	10,018ms	32,950ms	67,132ms	103,409ms
2회	1,130ms	10,522ms	33,070ms	63,889ms	100,594ms
3회	1,122ms	7,368ms	35,575ms	63,003ms	123,075ms
평균(avg)	1,124ms	9,303ms	33,865ms	64,675ms	109,026ms

◼️ 서버 테스트 결과

서버 테스트 결과: hi, si 발생하지 않음.
컴파일: g++ atomic_flag.cc -o atomic_flag -lpthread -> 실행 파일 크기: 25888

소요시간: thread=1,5

회	thread=1	thread=5
1회	2,287ms	56,559ms
2회	2,277ms	55,634ms
3회	2,277ms	53,772ms
평균(avg)	2,280ms	55,322ms

◼️ 서버: 컴파일 최적화 옵션 -O2 적용

컴파일: g++ -O2 atomic_flag.cc -o atomic_flag -lpthread -> 실행 파일 크기: 15728
Redis도 컴파일 최적화 옵션 -O2를 적용함
테스트 결과: 최적화 옵션 적용 후 많이 빨라짐.

회	thread=1	thread=5
1회	744ms	44,082ms
2회	750ms	50,429ms
3회	745ms	45,152ms
평균(avg)	746ms	46,554ms

Email 답글이 올라오면 이메일로 알려드리겠습니다.