Discussion :

[Roland Chastain]

Bonjour tout le monde !

Il existe une multitude de moteurs d'échecs écrits en Pascal, dont certains qui sont très, très forts (comme Booot).

Feuerstein est un de mes préférés. Il joue très bien (sans être un monstre comme le précédent). Il est même capable de jouer à une variante (Crazyhouse), et pour cette variante il accepte les deux protocoles CECP et UCI. En à peine un millier de lignes !

Au départ, c'est un programme Delphi. Je l'ai légèrement retouché pour le compiler avec Free Pascal et supprimer la dépendance à l'unité Windows. J'ai fait aussi une petite correction (qui m'a été indiquée ici) pour permettre la compilation 64 bits.

Resterait éventuellement 1° à adapter les parties en assembleur (pour qu'on puisse les activer aussi dans la version 64 bits), et 2° à vérifier que le programme peut toujours être compilé avec Delphi. Contributions bienvenues !

Le programme est là : (* https://codeberg.org/rchastain/feuerstein *)

[anapurna]

Salut

Pour le ASM 64 bits :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
procedure Schiebe;
ASM
; Version 64 bits
PUSH RBX          ; Sauvegarde RBX (registre 64 bits)
MOV RBX, RDX      ; RBX = RDX (registres 64 bits)
 
@Anfang: 
ADD AL, BL        ; Addition 8 bits (inchangé)
TEST AL, 136      ; Test 8 bits (inchangé)
JNZ @Ende         ; Saut conditionnel (inchangé)
 
PUSH RAX          ; Sauvegarde RAX (registre 64 bits)
CALL Setze        ; Appel de fonction (inchangé)
POP RAX           ; Restauration RAX (registre 64 bits)
 
MOV RCX, qword ptr [PL]  ; Chargement d'une adresse 64 bits
CMP byte ptr [RCX+RAX+Lage.Br], 0  ; Comparaison avec offset 64 bits
JZ @Anfang        ; Saut conditionnel (inchangé)
 
@Ende: 
POP RBX           ; Restauration RBX (registre 64 bits)
END;

Principales modifications pour la version 64 bits :

Registres étendus : EBX → RBX, EDX → RDX, EAX → RAX, ECX → RCX
Opérations sur les registres bas : AL et BL restent identiques (registres 8 bits)
Adressage mémoire : La ligne MOV ECX, PL devient MOV RCX, qword ptr [PL] pour charger une adresse 64 bits
Calcul d'adresse : [RCX+RAX+Lage.Br] utilise maintenant des registres 64 bits pour l'adressage

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
PROCEDURE TestSetze(Ziel: Integer);
ASM 
  ADD RAX, qword ptr [Quell]  // Addition avec valeur 64 bits
  TEST AL, 136                // Test sur le registre bas (inchangé)
  JNZ @Ende                   // Saut conditionnel (inchangé)
  CALL Setze                  // Appel de procédure (inchangé)
  @Ende:                      // Label de fin
END;

Modifications principales pour 64 bits :

Registre étendu : EAX → RAX (registre 64 bits)
Accès mémoire : ADD EAX, Quell → ADD RAX, qword ptr [Quell]

Utilise un pointeur 64 bits pour accéder à la variable Quell
qword ptr spécifie explicitement un accès 64 bits

Opérations inchangées :
TEST AL, 136 : reste identique (opération sur 8 bits)
JNZ @Ende : saut conditionnel inchangé
CALL Setze : appel de procédure inchangé

Notes importantes :
Le paramètre Ziel: Integer reste un entier 32 bits en Pascal
En 64 bits, RAX est automatiquement le registre de retour/paramètre principal
La variable Quell doit être accessible dans la portée de la procédure
La procédure Setze doit également être adaptée pour 64 bits si nécessaire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
FUNCTION Entnimm(VAR S: String): String;
ASM
  MOV RCX, RDX        // Copie du pointeur/paramètre 64 bits
  XOR RDX, RDX        // Mise à zéro de RDX (64 bits)
  CALL EntnimmBis     // Appel de fonction (inchangé)
END;FUNCTION Entnimm(VAR S: String): String;

Modifications pour la version 64 bits :

Registres étendus : ECX → RCX (registre 64 bits) EDX → RDX (registre 64 bits)
Convention d'appel 64 bits :
RCX et RDX sont les premiers registres de paramètres en convention Win64
MOV RCX, RDX copie le deuxième paramètre vers le premier
XOR RDX, RDX remet à zéro le deuxième paramètre

Gestion des chaînes :
En 64 bits, les pointeurs de chaînes sont des adresses 64 bits
Le paramètre VAR S: String est passé par référence (pointeur 64 bits)
La valeur de retour String utilise également des pointeurs 64 bits

Points importants :
L'instruction CALL EntnimmBis reste identique
La fonction EntnimmBis doit également être adaptée pour 64 bits
Les conventions d'appel 64 bits peuvent différer selon le compilateur (Win64, SysV, etc.)
La gestion mémoire des chaînes Pascal utilise désormais des adresses 64 bits

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
PROCEDURE Setze(Ziel: Integer);
  ASM
    MOV RDX, Z                              // RDX := adresse de Z (directe)
    MOVSXD RAX, EAX                         // Étendre Ziel de 32 à 64 bits
    ADD RDX, RAX                            // RDX := @(Z^[Ziel])
 
    MOV RCX, RAX                            // RCX := Ziel (64 bits)
    SHL RCX, 3                              // RCX := Ziel * 8
    ADD RCX, Q                              // RCX := @(Q^[Ziel])
 
    MOVZX RAX, byte ptr [RDX]               // RAX := Z^[Ziel] (extension zéro)
    ADD RCX, RAX                            // Inc(RCX, Z^[Ziel])
 
    MOV AL, byte ptr [Quell]                // AL := Quell
 
    CMP byte ptr [Setzen], 0                // Comparer Setzen avec 0
    JZ @negativ
 
    // Branche positive
    MOV byte ptr [RCX], AL                  // Q^[Ziel, Z^[Ziel]] := Quell
    INC byte ptr [RDX]                      // Inc(Z^[Ziel])
    INC dword ptr [Beweg]                   // Inc(Beweg)
    RET
 
  @negativ:
    DEC byte ptr [RDX]                      // Dec(Z^[Ziel])
    DEC dword ptr [Beweg]                   // Dec(Beweg)
    MOV AH, byte ptr [RCX-1]                // AH := Q^[Ziel, Z^[Ziel]]
 
  @Finde: 
    DEC RCX                                 // Décrémenter pointeur 64 bits
    CMP byte ptr [RCX], AL                  // Comparer avec AL
    JNE @Finde                              // Continuer si différent
    MOV byte ptr [RCX], AH                  // Remplacer par AH
  END;

Extension de registres :
MOVSXD RAX, EAX : étend le paramètre Ziel (32 bits) vers 64 bits avec extension de signe
Tous les registres principaux utilisent maintenant la version 64 bits (RAX, RCX, RDX)

Calcul d'adresses :
SHL RCX, 3 : multiplication par 8 pour l'adressage 64 bits (au lieu de 4 en 32 bits)
Les opérations de pointeur utilisent des registres 64 bits

Opérations sur bytes :
Les opérations sur AL, AH et les accès byte ptr restent identiques
La logique de recherche dans @Finde est préservée

Points importants :
La logique algorithmique reste identique
Les tableaux Z et Q sont maintenant adressés avec des pointeurs 64 bits
La boucle de recherche @Finde fonctionne avec des adresses 64 bits

J'ai essayé de maintenir la logique de manipulation des paramètres tout en utilisant l'architecture 64 bits.

[Roland Chastain]

@anapurna

Merci beaucoup.

J'ai incorporé ton code et vais faire des essais.

Un détail. Je n'ai pas compris pourquoi la fonction EntnimmBis doit être modifiée.

[Roland Chastain]

@anapurna

La version ASM 64 bits fonctionne parfaitement.

Je suis en train de faire des essais avec l'option Lernen activée. Je suis curieux de voir si le jeu du moteur s'améliore vraiment avec le temps.

[anapurna]

Salut

La fonction EntnimmBis doit être en 64 bits (ce qui est le cas si tu compiles en 64 bits).
Ce que je voulais dire c'est que selon le compilateur, il faut que tu inclues des options de compilation du genre {$IFDEF COMP64}...{$ELSE}{IFDEF COMP32} ...{$END}...{$END}.

[Guesset]

Bonjour,

J'ai regardé le code, mais n'étant pas sous Linux cela me limite.

Cependant, j'ai remarqué que les codes Assembleur sont de simples allitérations d'un code Pascal bien écrit. Je doute donc que ces portions Assembleur apportent un réel gain de performances. En effet, quand le codage Assembleur consiste seulement à faire le travail du compilateur, autant laisser ce dernier faire le job.

Ce serait différent si des instructions spéciales comme les opérations de haut niveau telles bsr, bsf, popcnt ou des instructions vectorielles étaient mises à contribution.
Mais ce n'est pas le cas, et même l'entrelacement de code qui favorise le "out of order" n'est pas utilisé. De plus, l'option de suppression de cadre de pile n'est apparemment pas activée, ce qui induit des empilages et dépilages cachés et inutiles.

Je conseillerais donc de vérifier que ce code Assembleur apporte réellement quelque chose. Si ce n'est pas le cas, le supprimer.

Salutations

[Roland Chastain]

Je conseillerais donc de vérifier que ce code assembleur apporte réellement quelque chose. Si ce n'est pas le cas, le supprimer.

Merci d'avoir regardé et merci pour cet avis intéressant.

Ne connaissant rien à l'Assembleur, je ne peux évaluer la chose que de façon empirique. Les essais que j'ai faits jusqu'à présent semblent montrer un léger avantage pour les versions avec Assembleur, mais c'est peut-être un hasard.

Code X :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
438 game(s) loaded, 0 game(s) with unknown result ignored.
Rank Name                                      Elo    +    - games score oppo. draws 
   1 GreKo 2021.10                             330  306  180    12   92%   -27    0% 
   2 CT800 1.12                                114  167  147    12   71%   -27   25% 
   3 Uralochka 1.1d RC                          49  158  146    12   63%   -27   25% 
   4 King Slayer                                24   93   90    36   57%   -27   19% 
   5 Feuerstein 0.4.6.1 RC 0.3 64-bit LERNEN    21   47   46   128   57%   -29   32% 
   6 Feuerstein 0.4.6.1 RC 0.3 32-bit LERNEN     3   46   46   128   54%   -27   32% 
   7 Feuerstein 0.4.6.1 RC 0.3 32-bit ASM      -18   46   46   128   51%   -23   31% 
   8 Feuerstein 0.4.6.1 RC 0.3 64-bit ASM      -28   47   47   128   49%   -21   27% 
   9 Feuerstein 0.4.6.1 RC 0.3 32-bit          -46   47   47   128   46%   -18   29% 
  10 Feuerstein 0.4.6.1 RC 0.3 64-bit          -91   48   49   128   39%   -10   20% 
  11 Stash 13.0.1                             -111  106  113    24   38%   -27   25% 
  12 Sjaak II 1.4.1                           -246  158  203    12   21%   -27    8%

Pareil pour les versions compilées avec le switch {$DEFINE Lernen} : je ne sais pas si elles sont vraiment plus fortes comme les résultats ci-dessus en donnent l'impression. En tout cas elles fonctionnent...

J'ai regardé le code, mais n'étant pas sous Linux cela me limite.

Le programme compile sous Windows. Il n'y a que le Makefile qui n'était pas adapté, mais entre-temps je l'ai mis à jour.