S>А чем sprintf плох?
Он более чем в 100 раз медленнее самого быстрого представленного тут способа

Здравствуйте, Аноним, Вы писали:

S>>А чем sprintf плох?
А>Он более чем в 100 раз медленнее самого быстрого представленного тут способа

Ещё есть boost::format... но мы лучше умолчим о его производительности

Если честно — все это хорошо, но возник вопрос.
А зачем производить 10М+ преобразование в hex-string-формат?
Может дело в проблеме архитектуры?

Здравствуйте, ДимДимыч, Вы писали:
<skipped>

Я думаю, что можно попробовать сделать быстрее, чем самый быстрый вариант (табл. 64K int-ов), если обрабатывать по 4 числа за раз.
Т.е. ф-ция примет примерно такой вид:

bool putLong(char *buffer, unsigned int n0, unsigned int n1, unsigned int n2, unsigned int n3)
{
    ;; далее псевдо-код))
    __asm{
        lea   eax, s_hexChars;
        mov   ebx, buffer;
        
        movd  mm0, n0;
        movd  mm1, mm0;

        psrld mm0, 16;          ;получили старшее dword
        pslld mm0, 2;           ;умношили на 4
        paddd mm0, eax;         ;получили адрес в таблице
        movd  mm0, [mm0];       ;как так сделать? загрузить в mm0 dword по адресу mm0

        pand  mm1, 0x0000ffff;  ;получили младшее dword (так тоже нельзя?)
        pslld mm1, 2;           ;умношили на 4
        paddd mm1, eax;         ;получили адрес в таблице
        movd  mm1, [mm1];       ;??? нужно загрузить в mm0 dword по адресу mm0
        psllq mm1, 32;          ;подвинули        
        por   mm0, mm1;         ;в mm0 результат

        movq  [ebx], mm0;       ;записали результат

        ;; тоже самое для n1, n2, n3 где будут задейстованы регистры mm2/mm3, mm4/mm5, mm6/mm7
        ;; результат класть  movq [ebx+8], mm2  и т.д.        
    }
}

цикл тогда примет примерно такой вид:

for(int i=0; i<1000000 / 4; i += 4)
    putLong(buff, i, i + 1, i + 2, i + 3);

возможно процессор выполнит часть инструкций параллельно (если их правильно перемешать)), типа:
чтение
выполнение--чтение
запись------выполнение--чтение
------------запись------выполнение--чтение
------------------------запись------выполнение
------------------------------------запись
насколько я понял из мануалов, чтение не может выполняться паралелльно чтению (и запись тоже)
а вот чтение/запись паралелльно выполняться может

т.е. я имел ввиду, ускорить самый быстрый вариант)

ДимДимыч wrote:

> С>Гораздо проще попытаться использовать расширенные наборы инструкций
> (MMX, SSE, SSE2).
>
> Вот вариант с MMX, который у меня работает на 13% быстрее, чем в
> исходном <Message.aspx?mid=2138136&only=1> посте:

[]

Интересно было бы получить этот код в виде, удобоваримом для gcc, чтобы вставить
его в тест.

--
Maxim Yegorushkin

No Microsoft product was used in any way to write or send this text.
If you use a Microsoft product to read it, you're doing so at your own risk

ДимДимыч wrote:

> С>Гораздо проще попытаться использовать расширенные наборы инструкций
> (MMX, SSE, SSE2).
>
> Вот вариант с MMX, который у меня работает на 13% быстрее, чем в
> исходном <Message.aspx?mid=2138136&only=1> посте:

Как он в сравнении с
http://groups.google.co.uk/group/comp.lang.asm.x86/msg/97df4e371eab3636
?

--
Maxim Yegorushkin

No Microsoft product was used in any way to write or send this text.
If you use a Microsoft product to read it, you're doing so at your own risk

Здравствуйте, MaximE, Вы писали:

ME>Как он в сравнении с
ME>http://groups.google.co.uk/group/comp.lang.asm.x86/msg/97df4e371eab3636
ME>?

Да, этот код быстрее моего.
Вот, я его портировал на gcc inline asm:

inline void mmx_init(void)
{
    static const unsigned long long consts[3] = 
    {
    0x3030303030303030LL,
    0x0f0f0f0f0f0f0f0fLL,
    0x0909090909090909LL
    };

    __asm__ __volatile__
    (
    "emms            \n"
    "movq (%0),  %%mm3    \n"
    "movq 8(%0),%%mm2    \n"
    "movq 16(%0), %%mm4    \n"
    : : "r" (consts)
    );
}


inline void bin2hex_mmx(char *buffer, unsigned int value)
{
    __asm__  __volatile__
    (
    "movl %0,%%eax        \n"
    "bswap %%eax        \n"

    "movq %%mm3,%%mm5    \n"

        "psubb %%mm4,%%mm5    \n"
        "movd %%eax, %%mm0    \n"
        "movq %%mm0,%%mm1    \n"
        "psrlq $4, %%mm0    \n"
        "pand %%mm2,%%mm0    \n"
        "pand %%mm2,%%mm1    \n"
        "punpcklbw %%mm1,%%mm0    \n"
        "movq %%mm0,%%mm1    \n"
        "pcmpgtb %%mm4,%%mm0    \n"
        "pand %%mm5,%%mm0    \n"
        "paddb %%mm3,%%mm1    \n"
        "paddb %%mm0,%%mm1    \n"
        "movq %%mm1,(%1)    \n"

    : :  "r" (value), "r" (buffer) : "eax"
    );
}

Но как оказалось, исходный вариант с таблицей, если его заинлайнить, работает еще быстрее этого

Здравствуйте, remark, Вы писали:

R>Здравствуйте, Аноним, Вы писали:

S>>>А чем sprintf плох?
А>>Он более чем в 100 раз медленнее самого быстрого представленного тут способа

R>Ещё есть boost::format... но мы лучше умолчим о его производительности

R>

А я уже помидоры заготовил. Мягонькие такие — больно не будет...