Таймер для замера времени выполнения операции на основе hpet

@TickTheHero · Регистрация: 30.07.2013

Author24 — интернет-сервис помощи студентам

Здравствуйте.
Собственно, необходимо вычислить временной интервал выполнения некоторой функции. Основное требование - максимальная точность.
Посоветовали использовать HPET. Поискав нашел всего один пример использования HPET, ну и собственно спецификации.
Разобраться с использованием таймеров HPET в Linux никак не получается, поэтому прошу вашей помощи.

Пример найденный мной

C++

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <memory.h>
#include <malloc.h>
#include <time.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/time.h>
#include <linux/hpet.h>
 
extern void hpet_fasync(int, const char **);
 
#include <sys/poll.h>
#include <sys/ioctl.h>
#include <signal.h>
 
 
int main(int argc, const char ** argv)
{
 
    argc--;
    argv++;
 
    if (!argc) {
        fprintf(stderr, "-hpet: requires command\n");
        return -1;
    }
 
    hpet_fasync(argc, argv);
 
    return 0;
}
 
static int hpet_sigio_count;
 
static void hpet_sigio(int val)
{
    fprintf(stderr, "hpet_sigio: called\n");
    hpet_sigio_count++;
}
 
void hpet_fasync(int argc, const char **argv)
{
    unsigned long       freq;
    int         iterations, i, fd, value;
    sig_t           oldsig;
    struct hpet_info    info;
 
    hpet_sigio_count = 0;
    fd = -1;
    
    oldsig = signal(SIGIO, hpet_sigio);
    
    if (oldsig == SIG_ERR) {
        fprintf(stderr, "hpet_fasync: failed to set signal handler\n");
        return;
    }
 
    fd = open(argv[0], O_RDONLY);
 
    if (fd < 0) {
        fprintf(stderr, "hpet_fasync: failed to open %s\n", argv[0]);
        return;
    }
 
 
    if ((fcntl(fd, F_SETOWN, getpid()) == 1) ||
        ((value = fcntl(fd, F_GETFL)) == 1) ||
        (fcntl(fd, F_SETFL, value | O_ASYNC) == 1)) {
        fprintf(stderr, "hpet_fasync: fcntl failed\n");
        goto out;
    }
 
    freq = atoi(argv[1]);
    iterations = atoi(argv[2]);
 
    if (ioctl(fd, HPET_IRQFREQ, freq) < 0) {
        fprintf(stderr, "hpet_fasync: HPET_IRQFREQ failed\n");
        goto out;
    }
 
    if (ioctl(fd, HPET_INFO, &info) < 0) {
        fprintf(stderr, "hpet_fasync: failed to get info\n");
        goto out;
    }
 
    fprintf(stderr, "hpet_fasync: info.hi_flags 0x%lx\n", info.hi_flags);
 
    if (info.hi_flags && (ioctl(fd, HPET_EPI, 0) < 0)) {
        fprintf(stderr, "hpet_fasync: HPET_EPI failed\n");
        goto out;
    }
 
    if (ioctl(fd, HPET_IE_ON, 0) < 0) {
        fprintf(stderr, "hpet_fasync, HPET_IE_ON failed\n");
        goto out;
    }
 
    for (i = 0; i < iterations; i++) {
        (void) pause();
    //  fprintf(stderr, "hpet_fasync: count = %d\n", hpet_sigio_count);
    }
 
out:
    fprintf(stderr, "hpet_fasync: count = %d\n", hpet_sigio_count);
    signal(SIGIO, oldsig);
 
    if (fd >= 0)
        close(fd);
 
    return;
}

@castaway · 03.08.2013, 09:55

Тут хороший пример: http://aufather.wordpress.com/... -in-linux/
Используешь как-то так:

C++

    timespec ts0, ts1, *pts;
    InitRdtsc();
    GetRdtscTime( &ts0 );
    ...
    func_to_measure();
    ...
    GetRdtscTime( &ts1 );
    pts = TimeSpecDiff( &ts1, &ts0 );
    ...

Добавлено через 3 минуты
P.S.: https://github.com/petersenna/rdtscbench

@TickTheHero · 16.08.2013, 17:01 **[ТС]**

Спасибо за помощь, но реализовал я это несколько по другому.
Если кому будет интересно, вот моя реялизация на Си под Linux:

Кликните здесь для просмотра всего текста

C++

#include <stdio.h>
#include <unistd.h>
#include <stdint.h> 
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <inttypes.h>
#include <time.h>
#include <math.h>
 
uint64_t time_in_fsec;
uint64_t *hpet_mmap_addr = 0;
uint64_t fsec_in_tick = 0;
int hpet_fd;
 
extern int hpet_open() {
    
    int offset = 0xf0, 
        pg_offset,
        length = 0x3ff, 
        m_length;
        
        
    pg_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1);
    m_length = length + offset - pg_offset;
    
    hpet_fd = open("/dev/hpet", O_RDONLY);
    if (hpet_fd < 0) { 
        perror("hpet_open()->open()");
        return 1;
    }
 
    hpet_mmap_addr = (uint64_t *) mmap(NULL, m_length, PROT_READ, MAP_SHARED, hpet_fd, pg_offset);
    if (hpet_mmap_addr < 0) {
        perror("hpet_open()->mmap()");
        return 1;
    }
    
    fsec_in_tick = *hpet_mmap_addr >> 32;                       
    hpet_mmap_addr = (uint64_t *)((uint64_t)hpet_mmap_addr + offset);
    
    time_in_fsec = *hpet_mmap_addr * fsec_in_tick;
    
    return 0;
}
 
extern int hpet_close() {
    
    int offset = 0xf0, 
        pg_offset,
        length = 0x3ff, 
        m_length;
        
    pg_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1);
    m_length = length + offset - pg_offset;
 
    munmap(hpet_mmap_addr, m_length); 
    close(hpet_fd); 
    
    return 0;
}
 
extern int hpet_gettime(struct timespec *ts) {
 
    struct timespec t;
 
    t.tv_sec = time_in_fsec / 1000000000000000;
    t.tv_nsec = (time_in_fsec % 1000000000000000) / 1000000;
    
    *ts = t;
 
    return 0;
}

это предварительный вариант, которвый требует доработки... но работает))))

	16.08.2013, 17:01