benchmark.h File Reference

Go to the source code of this file.

Typedefs
typedef struct timer	timer
typedef struct recorder	recorder

Functions
timer *	timer_alloc ()
	Alloue un timer More...
void	start_timer (timer *t)
	Stoque le temps actuel comme début de la mesure dans t More...
long int	stop_timer (timer *t)
	Retourne le temps en nanosecondes depuis le début de mesure dans t More...
void	timer_free (timer *t)
	Retourne le temps en nanosecondes depuis le début de mesure dans t More...
void	update_overhead ()
	Mets à jours l'overhead More...
long int	get_overhead ()
recorder *	recorder_alloc (char *filename)
	Alloue un recorder More...
void	write_record (recorder *rec, long int x, long int time)
	Écris le temps time en correspondance avec x More...
void	write_record_n (recorder *rec, long int x, long int time, long n)
	Comme write_record mais divise time par n après avoir retiré l'overhead More...
void	recorder_free (recorder *rec)
	Libère toutes les resources utilisées par rec More...

Typedef Documentation

typedef struct recorder recorder

typedef struct timer timer

Function Documentation

long int get_overhead

(

)

                         {
  if (-1 == overhead) {
    update_overhead();
  }
  return overhead;
}

recorder* recorder_alloc

(

char *

filename

)

Alloue un recorder

Les données seront écrites dans le fichier filename. En cas d'erreur, il exit avec EXIT_FAILURE.

                                          {
  recorder *rec = (recorder *) malloc(sizeof(recorder));
  if (rec == NULL) {
    perror("malloc");
    exit(EXIT_FAILURE);
  }
  rec->output = fopen(filename, "w");
  if (rec->output == NULL) {
    perror("fopen");
    free(rec);
    exit(EXIT_FAILURE);
  }
  rec->overhead = get_overhead();
  return rec;
}

void recorder_free

(

recorder *

rec

)

Libère toutes les resources utilisées par rec

Parameters

rec	le recorder auquel il faut libérer les resources

                                   {
  fclose(rec->output);
  free(rec);
}

void start_timer

(

timer *

t

)

Stoque le temps actuel comme début de la mesure dans t

Parameters

t	Le temps dans lequel on stoque le temps de début

En cas d'erreur, affiche un message sur stderr et exit

                            {
#if   defined(BM_USE_CLOCK_GETTIME)
  if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &t->start)) {
    perror("clock_gettime");
    exit(EXIT_FAILURE);
  }
#elif defined(BM_USE_CLOCK_GETTIME_RT)
  if (clock_gettime(CLOCK_REALTIME, &t->start)) {
    perror("clock_gettime");
    exit(EXIT_FAILURE);
  }
#elif defined(BM_USE_CLOCK)
  t->start = clock();
  if (t->start == (clock_t) -1) {
    perror("clock");
    exit(EXIT_FAILURE);
  }
#elif defined(BM_USE_TIMES)
  if (times(&t->start) == -1) {
    perror("times");
    exit(EXIT_FAILURE);
  }
#else
  gettimeofday(&t->start, NULL);
#endif
}

long int stop_timer

(

timer *

t

)

Retourne le temps en nanosecondes depuis le début de mesure dans t

Parameters

t	Le temps dans lequel on a stoqué le temps de début

En cas d'erreur, affiche un message sur stderr et exit

                               {
  // time_t is only a 32 bits int on 32 bits machines
#if   defined(BM_USE_CLOCK_GETTIME) || defined(BM_USE_CLOCK_GETTIME_RT)
  struct timespec end;
  //if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end)) {
  if (clock_gettime(CLOCK_REALTIME, &end)) {
    perror("clock_gettime");
    exit(EXIT_FAILURE);
  }
  long total = GETTIME_TO_NSEC(end) - GETTIME_TO_NSEC(t->start);
#elif defined(BM_USE_CLOCK)
  clock_t end = clock();
  if (end == (clock_t) -1) {
    perror("clock");
    exit(EXIT_FAILURE);
  }
  long total = CLOCK_TO_NSEC(end) - CLOCK_TO_NSEC(t->start);
#elif defined(BM_USE_TIMES)
  struct tms end;
  if (times(&end) == -1) {
    perror("times");
    exit(EXIT_FAILURE);
  }
  long total = TIMES_TO_NSEC(end) - TIMES_TO_NSEC(t->start);;
#else
  struct timeval end;
  gettimeofday(&end, NULL);
  long total = GTOD_TO_NSEC(end) - GTOD_TO_NSEC(t->start);
#endif
  return total;
}

timer* timer_alloc

(

)

Alloue un timer

En cas de succès, retourne un timer, en cas d'erreur, affiche un message sur stderr et exit

                      {
  timer *t = (timer *) malloc(sizeof(timer));
  if (t == NULL) {
    perror("malloc");
    exit(EXIT_FAILURE);
  }
#if defined(BM_USE_TIMES)
  t->clock_ticks = sysconf(_SC_CLK_TCK);
  if (t->clock_ticks == -1) {
    free(t);
    perror("sysconf");
    exit(EXIT_FAILURE);
  }
#endif
  return t;
}

void timer_free

(

timer *

t

)

Retourne le temps en nanosecondes depuis le début de mesure dans t

Parameters

t	Le temps dans lequel on a stoqué le temps de début

En cas d'erreur, affiche un message sur stderr et exit

                           {
  free(t);
}

void update_overhead

(

)

Mets à jours l'overhead

                       {
  timer *t = timer_alloc();
  start_timer(t);
  overhead = stop_timer(t);
  timer_free(t);
  printf("overhead updated: %ld\n", overhead);
}

void write_record	(	recorder *	rec,
		long int	x,
		long int	time
	)

Écris le temps time en correspondance avec x

L'overhead est d'abord retiré de time En cas d'erreur, il exit avec EXIT_FAILURE

Parameters

rec	le recorder dans lequel écrire, il est supposé non-NULL
x	l'abscisse
time	le temps à écrire en ordonnée

                                                             {
  write_record_n(rec, x, time, 1);
}

void write_record_n	(	recorder *	rec,
		long int	x,
		long int	time,
		long	n
	)

Comme write_record mais divise time par n après avoir retiré l'overhead

                                                                       {
  fprintf(rec->output, "%ld, %ld\n", x, (time - rec->overhead) / n);
}