Как скомпилировать движок?

ассемблер х64 отличается от w32 - нужно просто поменять команды. и все будет компилироваться.

Используйте компилятор от Интел. Он поддерживает inline asm и встраивается в MS Windows (я использовал 2005 студию)

Код:

static __inline BYTE first_one(unsigned __int64 bm)
{ 
        __asm {
            bsf rax, qword ptr bm
        }

    /*
    __asm { mov  eax, dword ptr bm[0]
         test eax, eax
         jz   f_hi
         bsf  eax, eax
         jmp  f_ret
f_hi:    bsf  eax, dword ptr bm[4]
         add  eax, 20h
f_ret:

  }*/
}
///////////////////////////////////////////////////////////////////////////
static __inline BYTE last_one(unsigned __int64 bm)
{
        __asm {
            bsr rax, qword ptr bm
        }

    /*
    __asm { mov  eax, dword ptr bm[4]
         test eax, eax
         jz   l_lo
         bsr  eax, eax
         add  eax, 20h
         jmp  l_ret
l_lo:    bsr  eax, dword ptr bm[0]
l_ret:

  }*/
}

декларацию last_one и first_one не забудьте изменить

Я получил прирост скорости около 65% для 64 битной версии Стрелки

Есть в Стрелке еще одна критичная функция: popcnt, которая по сути своей 32-битная. Было бы полезно заменить ее на чисто 64-битный вариант:

int popcnt(unsigned __unt64 x)
{ x -= (x >> 1) & 0x5555555555555555;
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333);
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f;
x += x >> 8;
x += x >> 16;
x += x >> 32;
return x & 0xff;
}

На 32-битах этот вариант работает медленнее, но на 64 должен дать ощутимую прибавку в скорости.

Код:

#define MMX_POPCOUNT

#ifdef MMX_POPCOUNT
#include "amd3dx.h"

/* Athlon MMX optimized popcount function, based on AMD's Athlon
   optimization manuals */

FORCEINLINE int Count(BITBOARD v)
{
    static const __int64 C55 = 0x5555555555555555;
    static const __int64 C33 = 0x3333333333333333;
    static const __int64 C0F = 0x0F0F0F0F0F0F0F0F;

    __asm {
        movd            mm0, word ptr v;
        punpckldq       mm0, word ptr v + 4;
        movq            mm1, mm0;
        psrld           mm0, 1;
        pand            mm0, [C55];
        psubd           mm1, mm0;
        movq            mm0, mm1;
        psrld           mm1, 2;
        pand            mm0, [C33];
        pand            mm1, [C33];
        paddd           mm0, mm1;
        movq            mm1, mm0;
        psrld           mm0, 4;
        paddd           mm0, mm1;
        pand            mm0, [C0F];
        pxor            mm1, mm1;
        psadbw(mm0, mm1);
        movd            eax, mm0;
        emms;
    }
}
#else
FORCEINLINE int Count(BITBOARD a)
{
/* I think Dann stole this code from Crafty */
    __asm {                                             
           mov  ecx, dword ptr a                        
           xor eax, eax                                 
           test ecx, ecx                                
           jz l1                                        
    l0:                                                 
           lea edx, [ecx - 1]                           
           inc eax                                      
                   and ecx, edx                     
           jnz l0                                       
    l1:                                                 
           mov ecx, dword ptr a + 4                     
           test ecx, ecx                                
           jz l3                                        
    l2:                                                 
           lea edx, [ecx - 1]                           
           inc eax                                      
                   and ecx, edx                     
           jnz l2                                       
    l3:                                                 
    }                                                   
}
#endif

#endif

это для 32 бит (вытащил из беовульфа). на 64 скорей всего не прокатит.

Этот крафтевый вариант PopCnt мне уже предлагал кто-то из токчесса. Но потом сам автор признал, что он медленнее стрелкиного. Циклы, однако...

Вообще, на эту тему можно найти информацию в сети по ключевым словам "hamming weight". Там несколько вариантов этой функции.

thenewone Накосячил чего-то ваш рационализатор. Не хочет получаться, хоть тресни. Крафту 22.0 получается на ура, а 22.0rj - нет. Вернее файл *.exe получается, но в оболочке сразу падает. То ли в коде ошибки, то ли в Makefile, трудно сказать.
Чего делать то?

Насчет интел компилятора - он платный/бесплатный и где взять

thenewone Отослал рецепт.

Спасибо, дуп. Письмо получил, все понятно, попытаюсь скомпилировать
Бесконечно благодарен
Евгений