UINT64 UTC время - PullRequest
Новая
       12

UINT64 UTC время

2 голосов
/ 21 мая 2009

У меня дата в формате UTC без форматирования, хранящегося в формате uint64, т.е. Мне нужно вывести часы, минуты, секунды и миллисекунды из этого времени. Я могу сделать это очень легко, преобразовав его в строку и используя подстроку. Однако этот код должен быть очень быстрым, поэтому я бы хотел избежать манипуляций со строками. Есть ли более быстрый способ, возможно, используя битовые манипуляции для этого? Да, кстати, это должно быть сделано в C ++ в Linux.

Ответы [ 2 ]

8 голосов
/ 21 мая 2009 
uint64 u = 20090520145024798;
unsigned long w = u % 1000000000;
unsigned millisec = w % 1000;
w /= 1000;
unsigned sec = w % 100;
w /= 100;
unsigned min = w % 100;
unsigned hour = w / 100;
unsigned long v = w / 1000000000;
unsigned day = v % 100;
v /= 100;
unsigned month = v % 100;
unsigned year = v / 100;

Причина, по которой это решение переключается с uint64 u на unsigned long w (и v) в середине, заключается в том, что YYYYMMDD и HHMMSSIII соответствуют 32 битам, а 32-битное деление выполняется быстрее, чем 64-битное деление на некоторые системы.

6 голосов
/ 21 мая 2009

Для того, чтобы опираться на pts и предложения одного человека, вот пример их подходов с использованием 32-разрядных и 64-операций на процессоре с ядром 2: 

#include <stdio.h>
#include <sys/time.h>
#include <sys/resource.h>

typedef unsigned long long uint64;

struct outs {
    unsigned millisec, sec, min, hour, day, month, year;
};

void tbreakdown2(uint64 u, struct outs *outp) {
    outp->millisec = u % 1000;
    u /= 1000;
    outp->sec = u % 100;
    u /= 100;
    outp->min = u % 100;
    u /= 100;
    outp->hour = u % 100;
    unsigned long v = u / 100;
    outp->day = v % 100;
    v /= 100;
    outp->month = v % 100;
    outp->year = v / 100;
}


void tbreakdown(uint64 u, struct outs *outp) {
    unsigned int  daypart, timepart; //4000000000
                                     //  YYYYMMDD
                                     //HHMMssssss

    daypart = u / 1000000000ULL;
    timepart = u % 1000000000ULL;

    outp->millisec = timepart % 1000;
    timepart /= 1000;
    outp->sec = timepart % 100;
    timepart /= 100;
    outp->min = timepart % 100;
    timepart /= 100;
    outp->hour = timepart;

    outp->day = daypart % 100;
    daypart /= 100;
    outp->month = daypart % 100;
    daypart /= 100;
    outp->year = daypart;
}

uint64 inval = 20090520145024798ULL;

void printstruct(uint64 u, struct outs *outp) {
    printf("%018llu\n", u);
    printf("%04d-%02d-%02d %02d:%02d:%02d.%04d\n",
            outp->year, outp->month, outp->day,
            outp->hour, outp->min, outp->sec,
            outp->millisec);
}

void print_elapsed(struct timeval *tv_begin, struct timeval *tv_end) {
    unsigned long long mcs_begin, mcs_end, mcs_delta;

    mcs_begin = (unsigned long long)tv_begin->tv_sec * 1000000ULL;
    mcs_begin += tv_begin->tv_usec;
    mcs_end = (unsigned long long)tv_end->tv_sec * 1000000ULL;
    mcs_end += tv_end->tv_usec;

    mcs_delta = mcs_end - mcs_begin;

    printf("Elapsed time: %llu.%llu\n", mcs_delta / 1000000ULL, mcs_delta % 1000000ULL);
}

int main() {
    struct outs out;
    struct outs *outp = &out;
    struct rusage rusage_s;
    struct rusage begin, end;

    __sync_synchronize();
    printf("Testing impl 1:\n");
    tbreakdown(inval, outp);
    printstruct(inval, outp);

    __sync_synchronize();
    getrusage(RUSAGE_SELF, &begin);
    for (int i = 0; i < 100000000; i++) {
        __sync_synchronize();
        tbreakdown(inval, outp);
        __sync_synchronize();
    }
    getrusage(RUSAGE_SELF, &end);
    print_elapsed(&begin.ru_utime, &end.ru_utime);

    printf("Testing impl 2:\n");
    tbreakdown2(inval, outp);
    printstruct(inval, outp);

    __sync_synchronize();
    getrusage(RUSAGE_SELF, &begin);
    for (int i = 0; i < 100000000; i++) {
        __sync_synchronize();
        tbreakdown2(inval, outp);
        __sync_synchronize();
    }
    getrusage(RUSAGE_SELF, &end);
    print_elapsed(&begin.ru_utime, &end.ru_utime);

    return 0;
}

И вывод: 

=====32-bit=====
Testing impl 1:
020090520145024798
2009-05-20 14:50:24.0798
Elapsed time: 6.840427
Testing impl 2:
020090520145024798
2009-05-20 14:50:24.0798
Elapsed time: 19.921245

=====64-bit=====
Testing impl 1:
020090520145024798
2009-05-20 14:50:24.0798
Elapsed time: 3.152197
Testing impl 2:
020090520145024798
2009-05-20 14:50:24.0798
Elapsed time: 4.200262

Как вы можете видеть, избегание лишних 64-битных манипуляций помогает даже в собственном 64-битном режиме - но в 32-битной версии имеет огромное значение.

Тестирование проводилось на процессоре core2duo T7500 с тактовой частотой 2,2 ГГц и компилировалось с использованием gcc 4.3.3 для -O3. Эти барьеры памяти, которые вы видите, должны гарантировать, что компилятор не будет пытаться оптимизировать фактическую операцию, в то же время позволяя ему встроить ее, если он выберет.

...