myvtm/libtoolkit/cputime.c

#include "precompile.h"
#include "cputime.h"
#include "memutil.h"
#include "intalgo.h"

#include <Mmsystem.h>
#include <assert.h>

#pragma comment(lib, "Winmm.lib")

static LARGE_INTEGER cpu_freq = {0};

TOOLKIT_API cputime_t cputime_now()
{
	LARGE_INTEGER now;
	QueryPerformanceCounter(&now);
	return (__int64)now.QuadPart;
}

TOOLKIT_API cputime_t cputime_per_usec()
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return cpu_freq.QuadPart/1000000;
}

TOOLKIT_API cputime_t cputime_per_msec()
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return cpu_freq.QuadPart/1000;
}

TOOLKIT_API cputime_t cputime_per_sec()
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return cpu_freq.QuadPart;
}

TOOLKIT_API unsigned int cputime_as_usec(cputime_t tm)
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return (unsigned int)(tm*1000000/cpu_freq.QuadPart);
}

TOOLKIT_API unsigned int cputime_as_msec(cputime_t tm)
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return (unsigned int)(tm*1000/cpu_freq.QuadPart);
}

TOOLKIT_API unsigned int cputime_as_sec(cputime_t tm)
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return (unsigned int)(tm/cpu_freq.QuadPart);
}

TOOLKIT_API unsigned int cputime_usec(cputime_t tm)
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return (unsigned int)(tm*1000000%cpu_freq.QuadPart);
}

TOOLKIT_API unsigned int cputime_msec(cputime_t tm)
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return (unsigned int)(tm*1000%cpu_freq.QuadPart);
}

TOOLKIT_API unsigned int cputime_sec(cputime_t tm)
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return (unsigned int)(tm%cpu_freq.QuadPart);
}

TOOLKIT_API cputime_t cputime_advance_msec(cputime_t t, unsigned int val)
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return t + val*cpu_freq.QuadPart/1000;
}

TOOLKIT_API cputime_t cputime_advance_sec(cputime_t t, unsigned int val)
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return t + val*cpu_freq.QuadPart;
}

TOOLKIT_API cputime_t cputime_advance_uec(cputime_t t, unsigned int val)
{
	if (cpu_freq.QuadPart == 0)
		QueryPerformanceFrequency(&cpu_freq);
	return t + val*cpu_freq.QuadPart/1000000;
}



TOOLKIT_API void mmtime_init(mmtime_t *inst, UINT resolution)
{
	TIMECAPS tc;
	timeGetDevCaps(&tc, sizeof(TIMECAPS));
	inst->resolution = min(max(resolution, tc.wPeriodMin) ,tc.wPeriodMax);
	timeBeginPeriod(resolution);/* set time resolution */
	inst->last_tick.LowPart = timeGetTime();
	inst->last_tick.HighPart = 0;
}

TOOLKIT_API void mmtime_term(mmtime_t *inst)
{
	timeEndPeriod(inst->resolution);
}

TOOLKIT_API void mmtime_now(mmtime_t *inst, LARGE_INTEGER *t)
{
	t->HighPart = inst->last_tick.HighPart;
	t->LowPart = timeGetTime();
	if (t->QuadPart < inst->last_tick.QuadPart) {
		t->HighPart++;
	}
	inst->last_tick.LowPart = t->LowPart;
	inst->last_tick.HighPart = t->HighPart;
}

struct multimedia_timer {
	struct mmtime_t mmtime;
	LARGE_INTEGER tm_start;
	int interval_num;
	int interval_den;
	LARGE_INTEGER trigger_count;

	HANDLE evt; /* sync event object */
	DWORD own_thread; /* cannot be used cross thread's boundary */
};

TOOLKIT_API multimedia_timer *multimedia_timer_create(UINT resolution)
{
	multimedia_timer *timer;

	if (resolution == 0)
		resolution = 1; /* default resolution */

	timer = MALLOC_T(multimedia_timer);
	if (timer) {
		timer->evt = CreateEvent(NULL, FALSE, FALSE, NULL);
		if (timer->evt) {
			timer->own_thread = GetCurrentThreadId();
			mmtime_init(&timer->mmtime, resolution);
			mmtime_now(&timer->mmtime, &timer->tm_start);
		} else {
			free(timer);
			timer = NULL;
		}
	}
	return timer;
}

TOOLKIT_API void multimedia_timer_destroy(multimedia_timer *timer)
{
	if (timer) {
		mmtime_term(&timer->mmtime);
		free(timer);
	}
}

TOOLKIT_API UINT multimedia_timer_actual_resolution(multimedia_timer *timer)
{
	return timer->mmtime.resolution;
}

TOOLKIT_API int multimedia_timer_sleep(multimedia_timer *timer, unsigned int delay)
{
	if (!timer)
		return -1;
	
	assert(GetCurrentThreadId() == timer->own_thread);

	if (delay) {
		if (timeSetEvent(delay, timer->mmtime.resolution, 
			(LPTIMECALLBACK)timer->evt, 0, 
			TIME_CALLBACK_EVENT_SET|TIME_ONESHOT)) {
				WaitForSingleObject(timer->evt, INFINITE);
		}
	}
	return 0;
}

TOOLKIT_API int multimedia_timer_abort(multimedia_timer *timer)
{
	if (!timer)
		return -1;
	SetEvent(timer->evt);
	return 0;
}

TOOLKIT_API int multimedia_timer_adaptive_sleep_init(multimedia_timer *timer, int interval_den, int interval_num)
{
	int t;
	if (!timer || !interval_num || !interval_den)
		return -1;
	t = gcd(interval_den, interval_num);
	interval_num /= t;
	interval_den /= t;
	assert(GetCurrentThreadId() == timer->own_thread);
	mmtime_now(&timer->mmtime, &timer->tm_start);
	timer->interval_den = interval_den;
	timer->interval_num = interval_num;
	timer->trigger_count.QuadPart = 0;
	return 0;
}

TOOLKIT_API int multimedia_timer_adaptive_sleep(multimedia_timer *timer)
{
	LARGE_INTEGER now;
	LARGE_INTEGER total;
	if (!timer)
		return -1;
	assert(GetCurrentThreadId() == timer->own_thread);
	mmtime_now(&timer->mmtime, &now);
	timer->trigger_count.QuadPart += 1;
	total.QuadPart = timer->tm_start.QuadPart + timer->trigger_count.QuadPart * 1000LL * timer->interval_num / timer->interval_den;
	if (now.QuadPart < total.QuadPart)
		multimedia_timer_sleep(timer, (unsigned int)(total.QuadPart - now.QuadPart));
	return 0;
}

/* example */

/*
static void print_time()
{
SYSTEMTIME st;
GetLocalTime(&st);
printf("[%04d-%02d-%02d %02d:%02d:%02d.%03d]\n", st.wYear, st.wMonth, st.wDay, 
st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
}

int main()
{
int i;
multimedia_timer *timer = multimedia_timer_create(1);
multimedia_timer_adaptive_sleep_init(timer, 90000, 3003);

print_time();

for (i = 0; i < 300; ++i) {
multimedia_timer_adaptive_sleep(timer);
//print_time();
}

print_time();

getchar();

multimedia_timer_destroy(timer);

return 0;
}

*/