[DirectX11] 058 Direct Compute

#pragma once
 
class Time
{
public:
	static Time* Get();
 
	static void Create();
	static void Delete();
 
	static bool Stopped() { return isTimerStopped; }
	static float Delta() { return isTimerStopped ? 0.0f : timeElapsed; }
 
	void Update();
	void Print();
 
	void Start();
	void Stop();
 
	float FPS() const { return framePerSecond; }
	float Running() const { return runningTime; }
 
private:
	Time(void);
	~Time(void);
 
	static Time* instance;// 싱글톤 객체
 
	static bool isTimerStopped;// 타이머 중지
	static float timeElapsed;// 이전 프레임으로부터 경과시간
 
 
	INT64 ticksPerSecond;// 초당 틱카운트
	INT64 currentTime;// 현재 시간
	INT64 lastTime;// 이전시간
	INT64 lastFPSUpdate;// 마지막 FPS 업데이트 시간
	INT64 fpsUpdateInterval;// fps 업데이트 간격
 
	UINT frameCount;// 프레임 수
	float runningTime;// 진행 시간
	float framePerSecond;// FPS
};
 
 
class Timer
{
public:
	Timer();
	~Timer();
 
	void Start(function<void()> func, int milliSec, UINT repeat = 0);
	void Stop();
 
private:
	mutex m;
 
	bool bComplete;
	UINT count;
};
 
 
class Performance
{
public:
	Performance();
 
	void Start();
	float End();
 
private:
	__int64 tick;
	__int64 start, end;
};

#include "framework.h"
#include "Time.h"
 
Time* Time::instance = NULL;
 
bool Time::isTimerStopped = true;
float Time::timeElapsed = 0.0f;
 
Time::Time(void) :
	ticksPerSecond(0), currentTime(0), lastTime(0), lastFPSUpdate(0), fpsUpdateInterval(0),
	frameCount(0), runningTime(0), framePerSecond(0)
{
	QueryPerformanceFrequency((LARGE_INTEGER *)&ticksPerSecond);
	fpsUpdateInterval = ticksPerSecond >> 1;
 
	/*TwBar* bar = TweakBar::Get()->GetBar();
	TwAddVarRO(bar, "Time", TW_TYPE_FLOAT, &framePerSecond, "");*/
}
 
Time::~Time(void)
{
 
}
 
Time* Time::Get()
{
	assert(instance != NULL);
 
	return instance;
}
 
void Time::Create()
{
	assert(instance == NULL);
 
	instance = new Time();
}
 
void Time::Delete()
{
	SafeDelete(instance);
}
 
void Time::Update()
{
	if (isTimerStopped) return;
 
	//1. 현재시간을 가져와 시간 간격 및 진행 시간을 계산한다.
	QueryPerformanceCounter((LARGE_INTEGER *)&currentTime);
	timeElapsed = (float)(currentTime - lastTime) / (float)ticksPerSecond;
	runningTime += timeElapsed;
 
 
	//2. FPS Update
	frameCount++;
	if (currentTime - lastFPSUpdate >= fpsUpdateInterval)
	{
		float tempCurrentTime = (float)currentTime / (float)ticksPerSecond;
		float tempLastTime = (float)lastFPSUpdate / (float)ticksPerSecond;
		framePerSecond = (float)frameCount / (tempCurrentTime - tempLastTime);
 
		lastFPSUpdate = (INT64)currentTime;
		frameCount = 0;
	}
 
	lastTime = currentTime;
}
 
void Time::Print()
{
 
}
 
void Time::Start()
{
	if (!isTimerStopped)
		assert(false);
 
	QueryPerformanceCounter((LARGE_INTEGER *)&lastTime);
	isTimerStopped = false;
}
 
void Time::Stop()
{
	if (isTimerStopped)
		assert(false);
 
	INT64 stopTime = 0;
	QueryPerformanceCounter((LARGE_INTEGER *)&stopTime);
	runningTime += (float)(stopTime - lastTime) / (float)ticksPerSecond;
	isTimerStopped = true;
}
 
 
Timer::Timer()
{
	bComplete = false;
 
	count = 0;
}
 
Timer::~Timer()
{
 
}
 
void Timer::Start(function<void()> func, int milliSec, UINT repeat)
{
	assert(bComplete == false);
 
	bComplete = false;
	thread t([=]()
	{
		while (true)
		{
			if (repeat > 0 && count == repeat)
				break;
 
			if (bComplete == true)
				break;
 
			count++;
			Sleep(milliSec);
 
			if (bComplete == true)
				break;
 
			func();
		}
 
		Stop();
	});
	t.detach();
}
 
void Timer::Stop()
{
	count = 0;
 
	bComplete = true;
}
 
 
Performance::Performance()
{
	QueryPerformanceFrequency((LARGE_INTEGER *)&tick);
}
 
void Performance::Start()
{
	QueryPerformanceCounter((LARGE_INTEGER *)&start);
}
 
float Performance::End()
{
	QueryPerformanceCounter((LARGE_INTEGER *)&end);
 
	//start~end 사이의 소요시간
	return (float)((double)(end - start) / tick * 1000.0f);
}

#pragma once
#include "Systems/IExecute.h"
 
class ThreadDemo : public IExecute
{
public:
	virtual void Initialize() override;
	virtual void Ready() override {}
	virtual void Destroy() override {}
	virtual void Update() override;
	virtual void PreRender() override {}
	virtual void Render() override;
	virtual void PostRender() override {}
	virtual void ResizeScreen() override {}
 
private:
	void ExecuteTimer();
	void ExecutePerfomence();
 
private:
	mutex m;
	float progress = 0.0f;
 
	Timer timer;
	Timer timer2;
};

#include "stdafx.h"
#include "ThreadDemo.h"
 
void ThreadDemo::Initialize()
{
	//ExecuteTimer();
	ExecutePerfomence();
}
 
void ThreadDemo::Update()
{
}
 
void ThreadDemo::Render()
{
}
 
 
void ThreadDemo::ExecuteTimer()
{
	timer.Start([]() //람다식
	{
		printf("Timer\n");
	}, 2000, 2); //2000ms(=2초)마다 2번 수행
 
	timer2.Start([]()
	{
		printf("Timer2\n");
	}, 3000);//뒤에 값이 없으니 default값인 0. 따라서 3000ms마다 무한번 실행.
}
 
void ThreadDemo::ExecutePerfomence()
{
	int arr[10000];
	for (int i = 0; i < 10000; i++)
		arr[i] = Math::Random(0, 100000);
 
	
	Performance p;
	p.Start();
	{
		sort(arr, arr + 10000);
	}
	float last = p.End();
 
	printf("총 수행시간 : %f\n", last);
}