Funções getitimer, setitimer no linux.

Protótipo:

int getitimer(int which, struct itimerval *curr_value);
int setitimer(int which, const struct itimerval *new_value,
              struct itimerval *old_value);

Header:

#include <sys/time.h>

Descrição:
O sistema fornece ao processo três timers, cada um relacionado a um domínio específico. Quando um desses timers expiram, um sinal é enviado ao processo.

Tipos de timers:

ITIMER_REAL
Mede o tempo real. Quando o tempo expira, o kernel envia o sinal: SIGALRM. Equivalente a função alarm();

ITIMER_VIRTUAL
Decrementa somente quando o código do processo está sendo executado no user space. Quando expira o sinal SIGVTALRM é enviado ao processo.

ITIMER_PROF
Decrementa quando o processo está sendo executado no user space e também quando o processo usa algum recurso do kernel, por exemplo, uma chamada de sistema. Pode ser combinado com o ITIMER_VIRTUAL, pois podemos saber o quanto de tempo está sendo consumido no kernal space. Ao expirar, envia o sinal SIGPROF para o processo.

Os valores passados para as funções, são definidos pelas seguintes estruturas:

struct itimerval {
    struct timeval it_interval;
    struct timeval it_value;
};

struct timeval {
    time_t      tv_sec;
    suseconds_t tv_usec;
};

A função getitimer() preenche a estrutura curr_value para o timer especificado pelo parâmetro which (ITIMER_REAL, ITIMER_VIRTUAL, ou ITIMER_PROF). O elemento it_value é preenchido com o valor restante para o timer expirar.
A função setitimer() especifica o novo valor do timer no campo new_value.

Nosso código:

#include <sys/time.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <math.h>

#define MAX_ARRAY 2000000

void printfRemain(char * message, struct itimerval * timer_1, struct itimerval * timer_2){
	if(!timer_1 || !timer_2)
		return;
	float time_1, time_2;
	time_1 = (float)((float)timer_1->it_value.tv_sec * 1000 + (timer_1->it_value.tv_usec / 1000));
	time_2 = (float)((float)timer_2->it_value.tv_sec * 1000 + (timer_2->it_value.tv_usec / 1000));
	printf("\n\t%s %f\n",message, ((time_1 - time_2)));
	printf("\n\tTime 1: %f\n\tSeconds: %d, Mili: %d\n", time_1, timer_1->it_value.tv_sec,
				timer_1->it_value.tv_usec / 1000);
	printf("\n\tTime 2: %f\n\tSeconds: %d, Mili: %d\n", time_2, timer_2->it_value.tv_sec,
			timer_2->it_value.tv_usec / 1000);

}

int main(){
	int x[MAX_ARRAY];
	int i;
	struct itimerval timeReal, timeRealRemain;
	struct itimerval timeVirtual, timeVirtualRemain;
	struct itimerval timeProf, timeProfRemain;

	FILE *fp;
	fp=fopen("test.txt", "w");

	memset(&timeReal, 0,sizeof(struct itimerval));
	memset(&timeRealRemain, 0,sizeof(struct itimerval));
	memset(&timeProf, 0,sizeof(struct itimerval));
	memset(&timeProfRemain, 0,sizeof(struct itimerval));
	memset(&timeVirtual, 0,sizeof(struct itimerval));
	memset(&timeVirtualRemain, 0,sizeof(struct itimerval));

	timeReal.it_value.tv_sec = 10;
	timeProf.it_value.tv_sec = 10;
	timeVirtual.it_value.tv_sec = 10;
	setitimer(ITIMER_REAL,&timeReal, NULL);
	setitimer(ITIMER_VIRTUAL, &timeVirtual, NULL);
	setitimer(ITIMER_PROF, &timeProf, NULL);

	for(i = 0; i < MAX_ARRAY; i++)
	{
		x[i] = (int)sqrt(i) + (int)pow (i,2);
		fprintf(fp, "Value: %d", x[i]);
	}
	for(i = 0; i < MAX_ARRAY; i++)
	{
		x[i] = (int)pow (i,2) + (int)sqrt(i);
		fprintf(fp, "Value: %d", x[i]);
	}
	for(i = 0; i < MAX_ARRAY; i++)
	{
		x[i] = (int)sqrt(i) + (int)pow (i,2);
		fprintf(fp, "Value: %d", x[i]);
	}
	for(i = 0; i < MAX_ARRAY; i++)
	{
		x[i] = (int)pow (i,2) + (int)sqrt(i);
		fprintf(fp, "Value: %d", x[i]);
	}

	fclose(fp);

	getitimer(ITIMER_REAL,&timeRealRemain);
	getitimer(ITIMER_VIRTUAL, &timeVirtualRemain);
	getitimer(ITIMER_PROF,&timeProfRemain);
	printfRemain("Elapsed in REAL: ",&timeReal ,&timeRealRemain);
	printfRemain("Elapsed in VIRTUAL: ",&timeVirtual ,&timeVirtualRemain);
	printfRemain("Elapsed in PROF: ",&timeProf ,&timeProfRemain);

	return 1;
}

Fonte: http://linux.die.net/man/2/setitimer

Deixe uma resposta