std::chrono::time_point OldTime= std::chrono::now();
while(true)
{
const std::chrono::time_point CurrentTime = std::chrono::now();
const double DeltaTime = std::chrono::duration_cast<std::chrono::milliseconds>(CurrentTime - OldTime) * 1000.0;
OldTime = CurrentTime;
//์์
std::this_thread::sleep_for(std::chrono::milliseconds(3)));
}
๋ฉ์ธ์ค๋ ๋๊ฐ ์๋ ๋ค๋ฅธ ์ค๋ ๋์์ ๋๋ ธ๋๋ฐ ์ด์ ๋ ๋ชจ๋ฅด๊ฒ ๋๋ฐ DeltaTime์ด ์ ๋์จ๋ค
milliseconds๋ก 3์ด ์ฌ์๋ฌ์ ํ๋ฒํ๊ฒ ๋์์ผ์ง ์ ์์ผ ๊ฑฐ ๊ฐ์๋ฐ nanoseconds์์ 1๋ก ์กํ
milliseconds๋ก 3ms ์ฌ์๋ฌ์ ํ๋ฒํ๊ฒ ๋์์ผ์ง ์ ์์ผ ๊ฑฐ ๊ฐ์๋ฐ nanoseconds์์ 1๋ก ์กํ
๋ญ๊ฐ ๋ฌธ์ ์ธ์ง ์ข๋ ๋ชจ๋ฅด๊ฒ ์ด
์ค๊ฐ์ ๋ฃจํ ๊ฑด๋ ์ ์๊ณ OldTime๋ ๊ฑด๋ ์ ์ด ์๋๋ฐ
Cpu์ฌ์ดํด ์ก์์ CyclePerTick ๋ฐ๊ณ ๊ณ์ฐํด๋ ๊ฒฐ๊ณผ๋ 0.00001 ์ด์ง๋๋ก ์น์ฐฝ๋์์ด
๋ญ ์ ๋ณด๊ฐ ํ๋๋ ์์ด์ ๋์์ค์๊ฐ ์๋ค ํ์ถ ์กฐ๊ฑด๋ ํ๊ธฐ ์๋์ด ์๊ณ ๋ฐ๋ณต๋ฌธ ์กฐ๊ฑด๋ ๊ทธ๋ฅ ์ฐธ์ด๋ผ ๊ณ์ ๋ํ ๊ณ
์์ ๋ถ๋ถ์ printf Helloworld ๋ฃ์ด๋ ๋๊ฐ์
โ๋ฉ์ธ์ค๋ ๋๊ฐ ์๋ ๋ค๋ฅธ ์ค๋ ๋์์ ๋๋ ธ๋๋ฐ ์ด์ ๋ ๋ชจ๋ฅด๊ฒ ๋๋ฐ ์ด๊ฒ ์ ๋์จ๋คโ ์์ ์ด๊ฒ๊ฐ ๋ญ ๋งํ๋์ง ๋ชจ๋ฅด๊ฒ ๋๋ฐ
๋น๋๊ธฐ ์์ ์ผ๋ก ๋๋ ธ์ ๋
์ฌ๋ฆฝ์ for๋ฌธ ๋งจ ์๋ก ์ฌ๋ ค์ผ ํ๋๊ฑฐ ์๋?
for๋ฌธ์ด ์๋๋ผ while๋ฌธ
while ๋ด์์ ํด์ผ์ง sleep์ ๋ฐ์ ๋จ์๋ฅผ ms๊น์ง ์ฌ๋ฆด ์ ์์ง
while ๋ฌธ ๋งจ ์๋ก ์ฌ๋ฆฌ๋ผ๋๊ฑด๋ฐ ๋ญ์๋ฆฌ์ง
while ๋งจ ์๋ก ์ฌ๋ ค๋ ๋๊ฐ์ ๊ฑฐ ๊ฐ์๋ฐ
์ฌ๋ฆฝํ๊ธฐ ์ ์ oldtime์ ๊ฐฑ์ ํ๋๋ฐ ๋น์ฐํ๊ฒ๋ CurrentTime๊ณผ oldtime์ ์ค์ฐจ๊ฐ ์๋์์ค์ด๋ผ CyclePerTick ์์ 0.000001 ์์์ ์ฐจ์ด๋ฐ์ ์๋์ค์ง
๊ทธ๋ฆฌ๊ณ ์๊ฐ์ค์ฐจ๋ฅผ ๊ตฌํ๊ณ ์ถ์ผ๋ฉด ์์ ์์์๊ฐ๊ณผ์์ ๋๋์๊ฐ์ ์ฐจ๋ฅผ ๊ตฌํด์ผ์ง
์ค์ฐจ๊ฐ ์ ์์ sleep์ผ๋ก ์ง์ฐ์์ผฐ๋๋ฐ
milliseconds๋ก 3์ด๋ฉด 3000์ ๋ฃ์ด์ผ์ง
์์ชฝ์ * 1000.0; ํด๋๊ณ ์๋์ ์ 3๋ง ๋ฃ์ด๋จ๋ ใ ใ
์ด๊ฑด ์คํ์ผ
sleep ์ฌ์ฉํด์ ms๋ก ๋์ฌ ์ ์๋ ์กฐ๊ฑด์ ์คฌ๋๋ฐ ์ ๋์์
DeltaTime ์ผ๋ก ๋ณํํ๊ธฐ ์ ์ milliseconds ๋ก ๋ฐ์์จ ๊ฐ์ ์ด๋ป๊ฒ ๋์ด?
milliseconds๋ก๋ ๊ฐ์ด ์ ๋์ค๊ณ nanoseconds์์ 1๋ก ๋ sleep์ ์ด์์๋ ๋ก๊ทธ ๋ดค๋๋ฐ ๋ก๊ทธ์์๋ ์๊ฐ์ ๋ง์ถ์ ์ ์ฐํ๋์ค๋๋ผ
DeltaTime๋ง ์ ๊ตฌํด์ง๊ณ ์์ด
ํน์๋ํด์ Windows::LARGE_INTEGER tCycles; Windows::QueryPerformanceCounter(&tCycles); (uint32)tCycles.QuadPart; ๋ก ์์ฐจ ๊ตฌํด๋ดค๋๋ฐ ์๋ 0์ ๊ฐ๊น๊ฒ ๋จ๋๋ผ
ํน์ high_resolution_clock ์ด๊ฑด ์์ฐ๋ ์ด์ ๊ฐ ์์ด? ๋ด ์๊ฐ์๋ ์ปดํจํฐ ๋ด๋ถ์ ์๊ณ๊ฐ์ด ์ ๋ฐ์ดํธ๊ฐ ์๋ผ์ ๊ฐ์ด ๊ทธ๋๋ก์ธ๊ฒ ์๋๊น? ์คํ๋ ค ๊ฑฐ๊พธ๋ก ์ ์ฉ์ ํด๋ณด๋ ๊ฒ๋ ์ข์๊ฒ ๊ฐ์. while((ํ์ฌ์๊ฐ - ๊ธฐ์กด ์๊ฐ) > ์ต์ ๋ธํ ๊ฐ) { sleep } ์ด๋ฌ๋ฉด ๋ค๊ฐ ์ํ๋ ์ต์๊ฐ ๋ณด๋ค๋ ํฐ ์๊ฐ ๊ฐ๊ฒฉ์ผ๋ก ์์ ์ ํ ์ ์๊ฒ ์ง
high_resolution_clock ์ steady_clock์ด๋ system_clock์ ๋ณ์นญ ์ค ํ๋์ผ
์ง๋ฌธ์ด ์ ์ด๋ฐ์ง ๋ชจ๋ฅด๊ฒ ์ "๋ฉ์ธ์ค๋ ๋๊ฐ ์๋ ๋ค๋ฅธ ์ค๋ ๋์์ ๋๋ ธ๋๋ฐ ์ด์ ๋ ๋ชจ๋ฅด๊ฒ ๋๋ฐ ์ด๊ฒ ์ ๋์จ๋ค" ์ฌ๊ธฐ์์ "์ด๊ฒ" ๊ฐ ๋ญ์? "Cpu์ฌ์ดํด ์ก์์ CyclePerTick ๋ฐ๊ณ ๊ณ์ฐํด๋ ๊ฒฐ๊ณผ๋ 0.00001 ์ด์ง๋๋ก ์น์ฐฝ๋์์ด" ์ฌ๊ธฐ์ "๊ฒฐ๊ณผ" ๊ฐ ๋ญ์? ๊ทธ๋๊น ๋ฌธ์ ๊ฐ ๋ญ๋๋๊ฑฐ์ ๋์ฒด
DeltaTime์ด ์ ๊ตฌํด์ง๊ณ ์์ด
std::this_thread::sleep_for(std::chrono::milliseconds(3)));์ผ๋ก 3๋ฐ๋ฆฌ์ด ์ฌ์ด์ผ ํ๋๋ฐ ์์ฌ๊ณ ๋์์ DeltaTime์ ์ถ๋ ฅํ๋ฉด 0.003์ด ์๋๊ณ ํจ์ฌ ์์ ๊ฐ์ด ๋์จ๋ค << ์ด๊ฒ ๋ฌธ์ ๋ผ๋๊ฑฐ์? ์๋๋ฉด ์์ 0์ผ๋ก ๋์จ๋ค๋๊ฑฐ์?
0์ด๋ 0.0001๋ก ๋์
์ค์ ๋ก 0.003๋ฅผ ์ฌ๋๋ฐ ์ถ๋ ฅํ์ ๋ 0์ด ๋์จ๋ค๋ ๊ฒ์? ์๋๋ฉด 0.003๋ ์์ฐ๋ค๋ ๊ฒ์?
์ง์ง ๋ณ ์ปค๋ฎค๋ํฐ์ ์ ์ ์์ด ๋ค ์ฌ๋ ค์ ๊ทธ๋ฐ๊ฐ๋ด ๋ฏธ์ํด ๋ค์ ์ ์ ํ๋ฉด main()ํจ์์ ์ค๋ ๋๊ฐ ์๋ ๋ค๋ฅธ ์ค๋ ๋์์ ๋๋ ธ๋๋ฐ DeltaTime์ด ์ด์ํ๊ฒ 1ms๋ณด๋ค ๋ฎ์ ๊ฐ์ผ๋ก ๋์ค๊ฑฐ๋ 0์ผ๋ก ๋์ค๊ณ ์์ด 3ms์ผ๋ก sleep์ ํด์ค์ DeltaTime์ด 0.003s๋ณด๋ค ๋์์ผ ๋๋๋ฐ ํ์ ํ ๋ฎ์ ๊ทธ๋ฐ๋ฐ ์ด์ํ๊ฒ ๋ก๊ทธ๋ฅผ ๋ณด๋ฉด sleep์ด ์ ์์ ์ผ๋ก ์ ์ฉ๋ ๊ฑธ ๋ณผ ์ ์์ด Windows::QueryPerformanceCounter๋ฅผ ์ฌ์ฉํด ์์ฐจ๋ฅผ ๊ตฌํด๋ดค๋๋ฐ๋ ๊ฒฐ๊ณผ๋ 0.00001s ์ด๋ ๊ฒ ๋์ค๊ณ ์์ ์จ๊ฐ ์ปค๋ฎค๋ํฐ๋ฅผ ๋ค ๋ค์ ธ๋ดค๋๋ฐ๋ ํด๊ฒฐ๋ฐฉ๋ฒ์ด ๋์ค์ง ์์
QueryPerformanceCounter๋ uint32 GetCycle(){ Windows::LARGE_INTEGER Cycles; Windows::QueryPerformanceCounter(&Cycles); return (uint32)Cycles.QuadPart;}uint32 StartCycle = GetCycle()while(true){
uint32 tCycle = GetCycle(); DeltaTiem = (tCycle - StartCycle) * AverageCycle() StartCycle = tCycle ; //์์ }
"๋ก๊ทธ๋ฅผ ๋ณด๋ฉด sleep์ด ์ ์์ ์ผ๋ก ์ ์ฉ๋ ๊ฑธ ๋ณผ ์ ์์ด" << ์ ์ ์์ ์ผ๋ก ์ ์ฉ๋๋ค๋ ๊ฒ์? ์๋ฅผ ๋ค์ด 3๋ฐ๋ฆฌ์ด๊ฐ ์๋๋ผ 3000๋ฐ๋ฆฌ์ด๋ก ํด๋๊ณ ๋ฐ๋ณต๋ฌธ ๋ด์ ์ถ๋ ฅ๋ฌธ์ ๋ฃ์ผ๋ฉด 3์ด๋ง๋ค ์ถ๋ ฅ์ด ๋๋๋ฐ DeltaTime์ 0์ผ๋ก ์ถ๋ ฅ์ด ๋๋ค๋ ๊ฑฐ์?
AverageCycle์ ์ฌ์ดํด๋น ์ด์ผ
//์์ ๋ถ๋ถ์ ๋ก๊ทธ๊ฐ ์ฐํ๊ฒ ๋ง๋ค์๊ฑฐ๋ ๊ทธ ๋ก๊ทธ์๋ ์ปดํจํฐ ์๊ฐ์ด ์ฐํ๋๋ฐ 0.003s ์ด์์ผ๋ก ์์ฐจ๊ฐ ์ ์ฉ๋ ๊ฑธ ๋ณผ ์ ์์ด ๊ทธ๋ฐ๋ฐ DeltaTime๋ง 0์ผ๋ก ๋์ DeltaTime์ ํ์ธํ๊ธฐ ์ํด์ OldTime = CurrentTime; ๋ฐ๋ก ์๋์ DeltaTime์ด ์ถ๋ ฅ๋๋ ๋ก๊ทธ๋ฅผ ๋ง๋ค์ด ๋ดค๋๋ฐ ์๋ 0.003s ์ด์์ ์์ฐจ๊ฐ ์ ์ฉ๋์ง๋ง ๊ฐ์ 0์ด๋ 0.001s ์๋์ผ
1. ๋ฉ์ธ์ค๋ ๋์์ ์ ์ฝ๋๋ฅผ ๋๋ ค๋ ๋๊ฐ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํจ? 2. 3๋ฐ๋ฆฌ์ด๊ฐ ์๋๋ผ 3000๋ฐ๋ฆฌ์ด ๊ฐ์ ์ถฉ๋ถํ ํฐ ๊ฐ์ ๋ฃ์ด๋ ๋๊ฐ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํจ? 3. ์ด ์ฝ๋๋ฅผ ์ฑํํ๋ ์ค๋ ๋๋ ๋จ ํ๋ฒ๋ง ์์ฑ๋๋ ๊ฒ์ด ๋ง์?
CurrentTime, OldTime์ std::chrono::time_point๋ก ์ ์ฅํ์ง ๋ง๊ณ float์ด๋ doubleํ์ผ๋ก ๋ฐ๊พธ๊ณ ๋๋ ค๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํจ?
๊ทผ๋ฐ ๊ฒ์ํด๋ณด๋๊น std::chrono::now() ๋ ์๊ณ std::chrono::system_clock::now๋ std::chrono::steady_clock::now๋ก ํธ์ถํด์ผํ๋๋ฐ ์ด ์ฝ๋๋ ์ ๋์๊ฐ๋๊ฑฐ์?
์ฎ๊ฒจ์ ๋๋ฐ ์ค์๋ก std::chrono::๊น์ง๋ง ์จ๋ฒ๋ ธ๋ค std::chrono::steady_clock:๋ก ์ ์ฉํ์ด ์ค๋ ๋๋ ๋จ ํ ๋ฒ๋ง ๋ง๋ค์ด์ง๊ณ std::this_thread::sleep_for(std::chrono::milliseconds(30));๋ก ํ ์คํธํด๋ดค๋๋ฐ DeltaTime์ด ์ ํํ์ง๋ ์์ง๋ง ๊ทธ๋๋ 0์ด ์๋ ๊ฐ์ด ๋์ค๊ธฐ ์์ํ์ด sleep์ด ๋๋ฌด ์งง์ผ๋ฉด ์์คํ ๋ด์์ ์ฒ๋ฆฌ๊ฐ ์ ๋๋๋ด
์ฐพ์๋ณด๊ณ ์๊ธดํ๋ฐ ํน์ 3ms๊น์ง sleep ์์ผ์ค ์ ์๋ ๋ฐฉ๋ฒ ์ข ์ ์ ์์๊น?
๊ท์ฐฎ์ผ๋ฉด ์ ํด์ค๋๊ด์ฐฎ์
๋ฌธ์ ๊ฐ ๊ฒฐ๊ตญ ๋ฐ๋ฆฌ์ด ๋จ์ ์ ํ๋๊ฐ ๋ณด์ฅ์ด ์๋ผ์ ์๊ธฐ๋ ๊ฒ ๊ฐ์๋ฐ ์ด๊ฑด ๊ฒฐ๊ตญ OS ์ค์ผ์ค๋ง ๋ฌธ์ ๋ผ์ ํด๊ฒฐ ์๋ ๋ฏ ์ถ์ ์ 3๋ฐ๋ฆฌ์ด์ ์งง์ ๊ฐ๊ฒฉ์ด ํ์ํ์ง๋ ๋ชจ๋ฅด๊ฒ ์ง๋ง ๊ทธ๋ฐ๊ฑธ ์๊ตฌํ๋ ๋ก์ง์ ์์ ํด์ผํ ๊ฒ์
๊ณ ๋ง์ ์ ๋ง ๋์์ด ๋ง์ด ๋์ด
์ QueryPerformanceCounter ์์ 64๋นํธ ๊ฐ์ ์ป์ด์์ 32๋นํธ๋ก ์ ๋ฐ๋๋ฅผ ๋ฎ์ถ ํ์ ๊ณ์ฐ์ ํ๋๊ฑฐ์ผ?
64bit์ 32bit ๋ฒ๊ฐ์๊ฐ๋ฉด์ ์ฌ์ฉํด๋ดค์ด
๊ทธ๋๋ ๊ฒฐ๊ณผ๋ ๋๊ฐ๋๋ผ
๊ทผ๋ฐ ๋ญํ๋๋ฐ ๋๋ ธ์ด ๊ฐ๊ฒฉ์ผ๋ก ์ฒ๋ฆฌ๊ฐ ํ์ํ ๊ฑฐ์ผ? ์ํ๋ ๊ฐฑ์ ๊ฐ๊ฒฉ์ด ์์๊ฑฐ ์๋์ผ? ๊ถ๊ธํ๋ค
ms๊น์ง๋ง ์ฌ๋ ค์ฃผ๋ฉด ๋๋๋ฐ sleep(std::chrono::milliseconds(3)) ์ฌ์ฉํ์์๋ ๋ถ๊ตฌํ๊ณ ๊ณ์ ๋๋ ธ์ด๋ก ๋์
์์ ๋ถํธ๋ฅผ ์๋ชป ์ ์๋๋ฐ while( std::chrono::duration_cast(std::chrono::now() - OldTime) < std::chrono::milliseconds(1) ) { sleep } ๊ธฐ์กด ์ฌ๋ฆฝ ์ฝ๋ ๋์ ์ด๋ ๊ฒ ์ฌ๋ฆฝ์ ํ๋ฉด ์ต์ 1ms ๋งํผ์ ์๊ฐ ์ฐจ์ด๊ฐ ๋๋ค๋ ๊ฑธ ๋ณด์ฅํ ์ ์์ ๊ฒ ๊ฐ์๋ฐ.
std::chrono::duration_cast(CurrentTime - OldTime).count() ๊ฐ ๊ณ์ 0์ด๋ 0.0001๋ก ๋์ค๊ณ ์๋๋ฐ ์ด๊ฒ ๋ถ์ ํํด์ ์ฌ์ฉํ ์ ์์ ๊ฑฐ ๊ฐ์
์๋ while ใ ใ ์ CurrentTime ์ค์ ํ์ง ๋ง๊ณ std::chrono::now() ๋ก ๊ฒ์ฌ ํ๋ผ๋๊น. while ๋๋ ๋ค์์ CurrentTime ์ now ๋ก ์ค์ .
while ๋ฌธ์ด ๋๋ฌ๋ค๋ ๊ฑด now() - OldTime ๊ฐ์ด ์ต์ ๊ฐ๋ณด๋ค ์ปค์ก๋ค๋ ๊ฒ์ด๊ณ (while ์กฐ๊ฑด๋ฌธ์ด ํธ์ถ ๋ ๋ ๋ง๋ค now() ์ด ๊ฐฑ์ ) ๊ทธ๋ผ while ๋ฌธ ์ด ํ์ DeltaTime = now() - OldTime ์ผ๋ก ์ค์ ํ๋ฉด DeltaTime ๊ฐ์ด ์ต์๊ฐ๋ณด๋ค ๋ฌด์กฐ๊ฑด ํด ์ ๋ฐ์ ์์์.
๋ด๊ฐ ์ํ๋ ๋งํผ sleep (3ms)์ ์ค์ ํ๋ฉด CurrentTime๊ณผ OldTime์ ์์ฐจ๊ฐ ๋งค์ฐ ์์์ ๊ธฐ๋์น๊ฐ ๋์ค์ง ์์ ์ต์ 30ms์ ํ์ํ๋๋ผ ๊ทธ๋ฆฌ๊ณ CurrentTime์ ๋ฏธ๋ฆฌ ์ค์ ํ์ง ์์ผ๋ฉด ๋ถ๋ช OldTime์์ ์์ฐจ๊ฐ ์๊ธธ ๊ฑฐ๊ณ ๋ถ์ ํํ ๊ฒฐ๊ณผ๊ฐ ๋์ฌ๊ฑฐ๋ผ๊ณ ์๊ฐํด
๊ธ ๋ค ์ฝ์ด๋ดค๋๋ฐ ๋ง์ฝ ๋๋ฒ๊ทธ๋ชจ๋๋ก ๋๋ฆฐ๊ฑฐ๋ฉด ๊ทธ๋ฅ ๋ฆด๋ฆฌ์ฆ๋ก ์คํํด๋ณด์
๋๋ฒ๊น ๋ชจ๋์์๋ thread sleep์ด ์ ์ฉ๋์ง ์๋๋ผ
์ง๊ธ ๋น์ฅ์ ์ข ์ด๋ ค์ธ ๊ฑฐ ๊ฐ๊ณ ๋์ค์ ํด๋ณผ ๊ฒ ๊ณ ๋ง์
์ฒซ๋ฃจํ๋ nano 1๋ก ๋์ค๋๊ฒ ๋ง์ ๊ทธ๋ฅ now - now ์๊ฐ ํ๊ฑฐ๋ผ.
์ฒซ๋ฃจํ ํ์๋ ๋์์ ๊ทธ๋
๊ทธ๋ผ ์ฝ๋๋ฅผ ์ฌ๋ ค๋ด.
์ ์์ ์ฌ๋ฆฐ ๊ฒ ๊ทธ ์ฝ๋์ธ๋ฐ duration_cast ํ ๋ std::chrono::steady_clock::now ์ฌ์ฉํ๊ณ
์ ์ฒด ์ฝ๋๋ ๊ฒฐ๊ณผ ์ค์ท ์ฐ์ด์ ๋ณด์ฌ์ค
์์๊ป ์ ํํ ์๊ฐ ์ธก์ ์ด ๋ถ๊ฐ๋ฅํ ์ฝ๋์์. oldtime์ด๋ current time์ฌ์ด ๋นผ๋๊ฑฐ๋ DeltaTime์ ํ ๋นํ๋๊ฑฐ๋ ์๊ฐ ๋ค๋ค์ด๊ฐ์์ผ๋๊น.
while ์กฐ๊ฑด ์ฒ๋ฆฌํ๋๋ฐ๋ ์๊ฐ์ฐ๊ณ
์ฌ๋ ธ์ด์
sleep์ผ๋ก ํ ์คฌ์ด์
์ ๋ชฉ์ ๋ก๊ทธ, ์ฝ๋